Ejemplo n.º 1
0
        // Token: 0x0600018E RID: 398 RVA: 0x000071C0 File Offset: 0x000053C0
        internal override void CheckChildrenLimit(int countLimit, int bytesLimit)
        {
            if (this.parser == null)
            {
                this.parser = new MimeAddressParser();
            }
            if (!this.parser.Initialized)
            {
                DecodingOptions headerDecodingOptions = base.GetHeaderDecodingOptions();
                this.parser.Initialize(base.Lines, false, false, headerDecodingOptions.AllowUTF8);
            }
            int i;

            for (i = 0; i <= countLimit; i++)
            {
                MimeStringList mimeStringList  = default(MimeStringList);
                MimeStringList mimeStringList2 = default(MimeStringList);
                if (AddressParserResult.End == this.parser.ParseNextMailbox(ref mimeStringList, ref mimeStringList2))
                {
                    this.parser.Reset();
                    return;
                }
                if (mimeStringList.Length > bytesLimit)
                {
                    throw new MimeException(Strings.TooManyTextValueBytes(mimeStringList.Length, bytesLimit));
                }
            }
            throw new MimeException(Strings.TooManyAddressItems(i, countLimit));
        }
 // Token: 0x060002FD RID: 765 RVA: 0x000108E8 File Offset: 0x0000EAE8
 public bool TryGetValue(DecodingOptions decodingOptions, out DecodingResults decodingResults, out string value)
 {
     if (decodingOptions.Charset == null)
     {
         decodingOptions.Charset = base.GetDefaultHeaderDecodingCharset(null, null);
     }
     if ((DecodingFlags.Rfc2231 & decodingOptions.DecodingFlags) != DecodingFlags.None)
     {
         if (this.segmentNumber == 0)
         {
             return(this.TryDecodeRfc2231(ref decodingOptions, out decodingResults, out value));
         }
         if (0 < this.segmentNumber)
         {
             throw new NotSupportedException(Strings.CantGetValueOfRfc2231ContinuationSegment);
         }
     }
     if (this.valueFragments.Length == 0)
     {
         decodingResults = default(DecodingResults);
         value           = ((this.decodedValue != null) ? this.decodedValue : string.Empty);
         return(true);
     }
     return(MimeCommon.TryDecodeValue(this.valueFragments, 4026531839U, decodingOptions, out decodingResults, out value));
 }
Ejemplo n.º 3
0
 public bool TryGetValue(DecodingOptions decodingOptions, out DecodingResults decodingResults, out string value)
 {
     this.AssertGood(true);
     if (this.reader.ReaderState == MimeReaderState.HeaderStart)
     {
         this.reader.TryCompleteCurrentHeader(true);
     }
     if (this.reader.CurrentHeaderObject != null)
     {
         TextHeader textHeader = this.reader.CurrentHeaderObject as TextHeader;
         if (textHeader != null)
         {
             value = textHeader.GetDecodedValue(decodingOptions, out decodingResults);
             if (decodingResults.DecodingFailed)
             {
                 value = null;
                 return(false);
             }
             return(true);
         }
         else
         {
             value = this.reader.CurrentHeaderObject.Value;
         }
     }
     else
     {
         value = null;
     }
     decodingResults = default(DecodingResults);
     return(true);
 }
Ejemplo n.º 4
0
        internal override void CheckChildrenLimit(int countLimit, int bytesLimit)
        {
            DecodingOptions headerDecodingOptions = base.GetHeaderDecodingOptions();
            ValueParser     parser = new ValueParser(base.Lines, headerDecodingOptions.AllowUTF8);

            this.ParseValue(parser, false);
            this.ParseParameters(ref parser, headerDecodingOptions, countLimit, bytesLimit);
        }
Ejemplo n.º 5
0
        protected void Parse()
        {
            this.parsed = true;
            DecodingOptions headerDecodingOptions = base.GetHeaderDecodingOptions();
            ValueParser     parser = new ValueParser(base.Lines, headerDecodingOptions.AllowUTF8);

            this.ParseValue(parser, true);
            this.ParseParameters(ref parser, headerDecodingOptions, int.MaxValue, int.MaxValue);
        }
Ejemplo n.º 6
0
 // Token: 0x06000550 RID: 1360 RVA: 0x0001D120 File Offset: 0x0001B320
 public bool TryGetValue(DecodingOptions decodingOptions, out DecodingResults decodingResults, out string value)
 {
     value = this.GetDecodedValue(decodingOptions, out decodingResults);
     if (decodingResults.DecodingFailed)
     {
         value = null;
         return(false);
     }
     return(true);
 }
Ejemplo n.º 7
0
 // Token: 0x0600019D RID: 413 RVA: 0x00007500 File Offset: 0x00005700
 public bool TryGetDisplayName(DecodingOptions decodingOptions, out DecodingResults decodingResults, out string displayName)
 {
     if (this.displayNameFragments.Count == 0)
     {
         displayName     = this.decodedDisplayName;
         decodingResults = default(DecodingResults);
         return(true);
     }
     if (decodingOptions.Charset == null)
     {
         decodingOptions.Charset = base.GetDefaultHeaderDecodingCharset(null, null);
     }
     return(MimeCommon.TryDecodeValue(this.displayNameFragments, 4026531839U, decodingOptions, out decodingResults, out displayName));
 }
Ejemplo n.º 8
0
        // Token: 0x0600024C RID: 588 RVA: 0x0000AD74 File Offset: 0x00008F74
        internal static bool TryDecodeValue(MimeStringList lines, uint linesMask, DecodingOptions decodingOptions, out DecodingResults decodingResults, out string value)
        {
            decodingResults = default(DecodingResults);
            if (lines.GetLength(linesMask) == 0)
            {
                value = string.Empty;
                return(true);
            }
            DecodingFlags decodingFlags          = decodingOptions.DecodingFlags;
            bool          flag                   = DecodingFlags.None != (DecodingFlags.FallbackToRaw & decodingFlags);
            bool          allowControlCharacters = DecodingFlags.None != (DecodingFlags.AllowControlCharacters & decodingFlags);
            bool          enable                 = false;
            bool          enableJisDetection     = false;
            bool          enableUtf8Detection    = false;
            bool          enableDbcsDetection    = false;
            Charset       defaultCharset         = null;
            ValueDecoder  valueDecoder           = new ValueDecoder(lines, linesMask);

            if ((decodingFlags & DecodingFlags.AllEncodings) == DecodingFlags.None)
            {
                if (!flag)
                {
                    defaultCharset = Charset.ASCII;
                }
            }
            else
            {
                enable              = (DecodingFlags.None != (DecodingFlags.Rfc2047 & decodingFlags));
                enableJisDetection  = (DecodingFlags.None != (DecodingFlags.Jis & decodingFlags));
                enableUtf8Detection = (DecodingFlags.None != (DecodingFlags.Utf8 & decodingFlags));
                enableDbcsDetection = (DecodingFlags.None != (DecodingFlags.Dbcs & decodingFlags));
                defaultCharset      = decodingOptions.Charset;
            }
            string         charsetName;
            string         cultureName;
            EncodingScheme encodingScheme;
            bool           flag2 = valueDecoder.TryDecodeValue(defaultCharset, flag, allowControlCharacters, enable, enableJisDetection, enableUtf8Detection, enableDbcsDetection, out charsetName, out cultureName, out encodingScheme, out value);

            decodingResults.EncodingScheme = encodingScheme;
            decodingResults.CharsetName    = charsetName;
            decodingResults.CultureName    = cultureName;
            decodingResults.DecodingFailed = !flag2;
            return(flag2);
        }
Ejemplo n.º 9
0
        // Token: 0x06000551 RID: 1361 RVA: 0x0001D13C File Offset: 0x0001B33C
        internal string GetDecodedValue(DecodingOptions decodingOptions, out DecodingResults decodingResults)
        {
            string result = null;

            if (base.Lines.Length == 0)
            {
                result          = ((this.decodedValue != null) ? this.decodedValue : string.Empty);
                decodingResults = default(DecodingResults);
                return(result);
            }
            if (decodingOptions.Charset == null)
            {
                decodingOptions.Charset = base.GetDefaultHeaderDecodingCharset(null, null);
            }
            if (!MimeCommon.TryDecodeValue(base.Lines, 4026531840U, decodingOptions, out decodingResults, out result))
            {
                result = null;
            }
            return(result);
        }
Ejemplo n.º 10
0
 // Token: 0x06000300 RID: 768 RVA: 0x000109E4 File Offset: 0x0000EBE4
 internal bool FallBackIfRequired(byte[] bytes, DecodingOptions decodingOptions, out string value)
 {
     if ((DecodingFlags.FallbackToRaw & decodingOptions.DecodingFlags) != DecodingFlags.None)
     {
         if (bytes == null)
         {
             value = string.Empty;
         }
         else
         {
             value = ByteString.BytesToString(bytes, decodingOptions.AllowUTF8);
             if ((DecodingFlags.AllowControlCharacters & decodingOptions.DecodingFlags) == DecodingFlags.None)
             {
                 value = MimeParameter.CorrectValue(value);
             }
         }
         return(true);
     }
     value = null;
     return(false);
 }
Ejemplo n.º 11
0
        // Token: 0x0600030B RID: 779 RVA: 0x000112A8 File Offset: 0x0000F4A8
        private bool TryDecodeRfc2231(ref DecodingOptions decodingOptions, out DecodingResults decodingResults, out string value)
        {
            decodingResults = default(DecodingResults);
            decodingResults.EncodingScheme = EncodingScheme.Rfc2231;
            Charset charset = null;

            byte[] sz  = this.valueFragments.GetSz(4026531839U);
            int    num = 0;

            if (this.valueEncoded)
            {
                int num2 = (sz == null) ? -1 : ByteString.IndexOf(sz, 39, 0, sz.Length);
                if (-1 < num2 && num2 < sz.Length - 1)
                {
                    int num3 = ByteString.IndexOf(sz, 39, ++num2, sz.Length - num2);
                    if (-1 < num3)
                    {
                        decodingResults.CharsetName = ByteString.BytesToString(sz, 0, num2 - 1, false);
                        decodingResults.CultureName = ByteString.BytesToString(sz, num2, num3 - num2, false);
                        if (!Charset.TryGetCharset(decodingResults.CharsetName, out charset))
                        {
                            decodingResults.DecodingFailed = true;
                            return(this.FallBackIfRequired(sz, decodingOptions, out value));
                        }
                        num = num3 + 1;
                    }
                }
            }
            if (charset == null)
            {
                charset = decodingOptions.Charset;
                if (charset == null)
                {
                    charset = DecodingOptions.DefaultCharset;
                }
            }
            decodingResults.CharsetName = charset.Name;
            Encoding encoding;

            if (!charset.TryGetEncoding(out encoding))
            {
                decodingResults.DecodingFailed = true;
                return(this.FallBackIfRequired(sz, decodingOptions, out value));
            }
            int num4 = this.valueFragments.Length - num;

            for (MimeNode mimeNode = base.FirstChild; mimeNode != null; mimeNode = mimeNode.NextSibling)
            {
                MimeParameter mimeParameter = mimeNode as MimeParameter;
                if (mimeParameter != null)
                {
                    num4 += mimeParameter.RawLength;
                }
            }
            byte[] array = new byte[num4];
            int    num5  = 0;

            if (sz != null && num < sz.Length)
            {
                num5 += this.DecodeRfc2231Octets(this.valueEncoded, sz, num, array, 0);
            }
            for (MimeNode mimeNode = base.FirstChild; mimeNode != null; mimeNode = mimeNode.NextSibling)
            {
                MimeParameter mimeParameter2 = mimeNode as MimeParameter;
                if (mimeParameter2 != null)
                {
                    byte[] rawValue = mimeParameter2.RawValue;
                    if (rawValue != null)
                    {
                        num5 += this.DecodeRfc2231Octets(mimeParameter2.valueEncoded, mimeParameter2.RawValue, 0, array, num5);
                    }
                }
            }
            value = ((num5 != 0) ? encoding.GetString(array, 0, num5) : string.Empty);
            if ((DecodingFlags.AllowControlCharacters & decodingOptions.DecodingFlags) == DecodingFlags.None)
            {
                value = MimeParameter.CorrectValue(value);
            }
            return(true);
        }
Ejemplo n.º 12
0
 public DecodingOptions(DecodingFlags decodingFlags)
 {
     this = new DecodingOptions(decodingFlags, null);
 }
Ejemplo n.º 13
0
        private void Parse()
        {
            this.Reset();
            this.parsed = true;
            DecodingOptions headerDecodingOptions = base.GetHeaderDecodingOptions();
            ValueParser     valueParser           = new ValueParser(base.Lines, headerDecodingOptions.AllowUTF8);
            MimeStringList  mimeStringList        = default(MimeStringList);
            MimeStringList  mimeStringList2       = default(MimeStringList);
            MimeString      mimeString            = default(MimeString);
            MimeString      mimeString2           = MimeString.Empty;

            ReceivedHeader.ParseState parseState = ReceivedHeader.ParseState.None;
            for (;;)
            {
                valueParser.ParseWhitespace(true, ref mimeStringList);
                byte b = valueParser.ParseGet();
                if (b == 0)
                {
                    break;
                }
                if (59 == b)
                {
                    parseState = ReceivedHeader.ParseState.Date;
                }
                else if (40 == b && parseState == ReceivedHeader.ParseState.DomainValue)
                {
                    parseState = ReceivedHeader.ParseState.DomainAddress;
                }
                else
                {
                    valueParser.ParseUnget();
                    mimeString = valueParser.ParseToken();
                    if (mimeString.Length == 0)
                    {
                        valueParser.ParseGet();
                        mimeStringList2.TakeOverAppend(ref mimeStringList);
                        valueParser.ParseAppendLastByte(ref mimeStringList2);
                        continue;
                    }
                    ReceivedHeader.ParseState parseState2 = this.StateFromToken(mimeString);
                    if (ReceivedHeader.ParseState.None != parseState2)
                    {
                        parseState = parseState2;
                    }
                }
                switch (parseState)
                {
                case ReceivedHeader.ParseState.Domain:
                case ReceivedHeader.ParseState.OptInfo:
                    if (mimeString2.Length != 0)
                    {
                        this.FinishClause(ref mimeString2, ref mimeStringList2, headerDecodingOptions.AllowUTF8);
                    }
                    else
                    {
                        mimeStringList2.Reset();
                    }
                    mimeString2 = mimeString;
                    valueParser.ParseWhitespace(false, ref mimeStringList);
                    mimeStringList.Reset();
                    parseState++;
                    break;

                case ReceivedHeader.ParseState.DomainValue:
                    mimeStringList2.TakeOverAppend(ref mimeStringList);
                    mimeStringList2.AppendFragment(mimeString);
                    break;

                case ReceivedHeader.ParseState.DomainAddress:
                {
                    bool flag = mimeString2.CompareEqI(ReceivedHeader.ParamFrom);
                    this.FinishClause(ref mimeString2, ref mimeStringList2, headerDecodingOptions.AllowUTF8);
                    mimeStringList.Reset();
                    valueParser.ParseUnget();
                    valueParser.ParseComment(true, false, ref mimeStringList2, true);
                    byte[] sz   = mimeStringList2.GetSz();
                    string text = (sz == null) ? null : ByteString.BytesToString(sz, headerDecodingOptions.AllowUTF8);
                    if (flag)
                    {
                        this.fromTcpInfoValue = text;
                    }
                    else
                    {
                        this.byTcpInfoValue = text;
                    }
                    mimeStringList2.Reset();
                    parseState = ReceivedHeader.ParseState.None;
                    break;
                }

                case ReceivedHeader.ParseState.OptInfoValue:
                    mimeStringList2.TakeOverAppend(ref mimeStringList);
                    mimeStringList2.AppendFragment(mimeString);
                    break;

                case ReceivedHeader.ParseState.Date:
                {
                    this.FinishClause(ref mimeString2, ref mimeStringList2, headerDecodingOptions.AllowUTF8);
                    mimeStringList.Reset();
                    valueParser.ParseWhitespace(false, ref mimeStringList);
                    valueParser.ParseToEnd(ref mimeStringList2);
                    byte[] sz2 = mimeStringList2.GetSz();
                    this.dateValue = ((sz2 == null) ? null : ByteString.BytesToString(sz2, false));
                    break;
                }

                case ReceivedHeader.ParseState.None:
                    mimeStringList2.Reset();
                    break;
                }
            }
            this.FinishClause(ref mimeString2, ref mimeStringList2, headerDecodingOptions.AllowUTF8);
        }
 // Token: 0x06000448 RID: 1096 RVA: 0x00018FB1 File Offset: 0x000171B1
 public bool TryGetDisplayName(DecodingOptions decodingOptions, out DecodingResults decodingResults, out string displayName)
 {
     this.AssertGood(true);
     return(this.reader.TryReadDisplayName(this.topLevel, decodingOptions, out decodingResults, out displayName));
 }
Ejemplo n.º 15
0
        internal void ParseParameters(ref ValueParser parser, DecodingOptions decodingOptions, int countLimit, int bytesLimit)
        {
            MimeStringList mimeStringList  = default(MimeStringList);
            MimeStringList mimeStringList2 = default(MimeStringList);
            bool           flag            = false;
            int            num             = 0;
            bool           flag2           = DecodingFlags.None != (DecodingFlags.Rfc2231 & decodingOptions.DecodingFlags);

            for (;;)
            {
                parser.ParseCFWS(false, ref mimeStringList, this.handleISO2022);
                byte b = parser.ParseGet();
                if (b != 59)
                {
                    if (b == 0)
                    {
                        break;
                    }
                    parser.ParseUnget();
                    parser.ParseSkipToNextDelimiterByte(59);
                }
                else
                {
                    parser.ParseCFWS(false, ref mimeStringList, this.handleISO2022);
                    MimeString mimeString = parser.ParseToken();
                    if (mimeString.Length != 0 && mimeString.Length < 128)
                    {
                        parser.ParseCFWS(false, ref mimeStringList, this.handleISO2022);
                        b = parser.ParseGet();
                        if (b != 61)
                        {
                            if (b == 0)
                            {
                                return;
                            }
                            parser.ParseUnget();
                        }
                        else
                        {
                            parser.ParseCFWS(false, ref mimeStringList, this.handleISO2022);
                            parser.ParseParameterValue(ref mimeStringList2, ref flag, this.handleISO2022);
                            if (2147483647 != countLimit || 2147483647 != bytesLimit)
                            {
                                if (++num > countLimit)
                                {
                                    goto Block_8;
                                }
                                if (mimeStringList2.Length > bytesLimit)
                                {
                                    goto Block_9;
                                }
                            }
                            else
                            {
                                bool valueEncoded = false;
                                int  num2         = -1;
                                if (flag2)
                                {
                                    int num3 = ByteString.IndexOf(mimeString.Data, 42, mimeString.Offset, mimeString.Length);
                                    if (num3 > 0)
                                    {
                                        int num4 = mimeString.Offset + mimeString.Length;
                                        int num5 = num3 + 1;
                                        num2 = 0;
                                        while (num5 != num4 && mimeString.Data[num5] >= 48 && mimeString.Data[num5] <= 57)
                                        {
                                            num2 = num2 * 10 + (int)(mimeString.Data[num5] - 48);
                                            if (10000 < num2)
                                            {
                                                num2 = -1;
                                                break;
                                            }
                                            num5++;
                                        }
                                        if (-1 != num2)
                                        {
                                            bool flag3 = 42 == mimeString.Data[num4 - 1];
                                            if (num5 < num4 - 1 || (num5 < num4 && !flag3))
                                            {
                                                num2 = -1;
                                            }
                                            else
                                            {
                                                valueEncoded = flag3;
                                                mimeString.TrimRight(num4 - num3);
                                            }
                                        }
                                    }
                                }
                                string        text          = Header.NormalizeString(mimeString.Data, mimeString.Offset, mimeString.Length, false);
                                MimeParameter mimeParameter = new MimeParameter(text);
                                mimeParameter.AppendValue(ref mimeStringList2);
                                mimeParameter.SegmentNumber = num2;
                                mimeParameter.ValueEncoded  = valueEncoded;
                                MimeNode mimeNode;
                                MimeNode nextSibling;
                                for (mimeNode = base.FirstChild; mimeNode != null; mimeNode = nextSibling)
                                {
                                    nextSibling = mimeNode.NextSibling;
                                    MimeParameter mimeParameter2 = mimeNode as MimeParameter;
                                    if (mimeParameter2 != null && mimeParameter2.Name == text)
                                    {
                                        break;
                                    }
                                }
                                if (0 >= num2)
                                {
                                    if (mimeNode != null)
                                    {
                                        mimeParameter.AllowAppend = true;
                                        for (MimeNode mimeNode2 = mimeNode.FirstChild; mimeNode2 != null; mimeNode2 = nextSibling)
                                        {
                                            nextSibling = mimeNode2.NextSibling;
                                            if (mimeNode2 is MimeParameter)
                                            {
                                                mimeNode.RemoveChild(mimeNode2);
                                                mimeParameter.InternalAppendChild(mimeNode2);
                                            }
                                        }
                                        mimeParameter.AllowAppend = false;
                                        base.InternalRemoveChild(mimeNode);
                                    }
                                    base.InternalAppendChild(mimeParameter);
                                }
                                else
                                {
                                    if (mimeNode == null)
                                    {
                                        MimeParameter mimeParameter3 = new MimeParameter(text);
                                        mimeParameter3.SegmentNumber = 0;
                                        base.InternalAppendChild(mimeParameter3);
                                        mimeNode = mimeParameter3;
                                    }
                                    MimeNode mimeNode3;
                                    MimeNode previousSibling;
                                    for (mimeNode3 = mimeNode.LastChild; mimeNode3 != null; mimeNode3 = previousSibling)
                                    {
                                        previousSibling = mimeNode3.PreviousSibling;
                                        MimeParameter mimeParameter4 = mimeNode3 as MimeParameter;
                                        if (mimeParameter4 != null && mimeParameter4.SegmentNumber <= num2)
                                        {
                                            break;
                                        }
                                    }
                                    MimeParameter mimeParameter5 = (MimeParameter)mimeNode;
                                    mimeParameter5.AllowAppend = true;
                                    mimeParameter5.InternalInsertAfter(mimeParameter, mimeNode3);
                                    mimeParameter5.AllowAppend = false;
                                }
                            }
                        }
                    }
                }
                if (b == 0)
                {
                    return;
                }
            }
            return;

Block_8:
            throw new MimeException(Strings.TooManyParameters(num, countLimit));
Block_9:
            throw new MimeException(Strings.TooManyTextValueBytes(mimeStringList2.Length, bytesLimit));
        }
Ejemplo n.º 16
0
 public bool TryGetValue(DecodingOptions decodingOptions, out DecodingResults decodingResults, out string value)
 {
     this.AssertGood(true);
     return(this.reader.TryReadParameterValue(decodingOptions, out decodingResults, out value));
 }
Ejemplo n.º 17
0
        // Token: 0x06000191 RID: 401 RVA: 0x000072A8 File Offset: 0x000054A8
        internal MimeNode ParseNextMailBox(bool fromGroup)
        {
            if (this.parsed)
            {
                return(null);
            }
            DecodingOptions headerDecodingOptions = base.GetHeaderDecodingOptions();

            if (this.parser == null)
            {
                this.parser = new MimeAddressParser();
            }
            if (!this.parser.Initialized)
            {
                this.parser.Initialize(base.Lines, false, false, headerDecodingOptions.AllowUTF8);
            }
            MimeStringList      displayNameFragments = default(MimeStringList);
            MimeStringList      mimeStringList       = default(MimeStringList);
            AddressParserResult addressParserResult  = this.parser.ParseNextMailbox(ref displayNameFragments, ref mimeStringList);

            switch (addressParserResult)
            {
            case AddressParserResult.Mailbox:
            case AddressParserResult.GroupInProgress:
            {
                MimeRecipient mimeRecipient = new MimeRecipient(ref mimeStringList, ref displayNameFragments);
                if (this.staticParsing)
                {
                    MimeRecipient.ConvertDisplayNameBack(mimeRecipient, displayNameFragments, headerDecodingOptions.AllowUTF8);
                }
                if (addressParserResult == AddressParserResult.GroupInProgress)
                {
                    MimeGroup mimeGroup = base.InternalLastChild as MimeGroup;
                    mimeGroup.InternalInsertAfter(mimeRecipient, mimeGroup.InternalLastChild);
                    return(mimeRecipient);
                }
                base.InternalInsertAfter(mimeRecipient, base.InternalLastChild);
                if (!fromGroup)
                {
                    return(mimeRecipient);
                }
                return(null);
            }

            case AddressParserResult.GroupStart:
            {
                MimeGroup mimeGroup = new MimeGroup(ref displayNameFragments);
                if (this.staticParsing)
                {
                    MimeRecipient.ConvertDisplayNameBack(mimeGroup, displayNameFragments, headerDecodingOptions.AllowUTF8);
                }
                base.InternalInsertAfter(mimeGroup, base.InternalLastChild);
                return(mimeGroup);
            }

            case AddressParserResult.End:
                return(null);

            default:
                return(null);
            }
        }
Ejemplo n.º 18
0
 internal DecodingOptions(string charsetName)
 {
     this = new DecodingOptions(DecodingOptions.Default.DecodingFlags, charsetName);
 }