Пример #1
0
        public void SetContent(byte[] content)
        {
            byte[] bytes = null;

            if (Encoding != TextEncoding.Binary)
            {
                if (Encoding == TextEncoding.QuotedPrintable)
                {
                    bytes = EncodedText.QuottedPrintableDecode(content, false);
                }
                else if (Encoding == TextEncoding.Base64)
                {
                    string base64Data = System.Text.Encoding.ASCII.GetString(content);
                    base64Data = ImapData.StripQuotes(base64Data, false);
                    bytes      = Convert.FromBase64String(base64Data);
                }
                else
                {
                    bytes = content;
                }
            }
            else
            {
                bytes = content;
            }

            SetContentInternal(bytes);
        }
Пример #2
0
        void SetContentInternal(byte[] bytes)
        {
            if (ContentType.MediaType.StartsWith("text/"))
            {
                System.Text.Encoding encoder = System.Text.Encoding.ASCII;
                if (ContentType.CharSet != null)
                {
                    encoder = System.Text.Encoding.GetEncoding(ContentType.CharSet);
                }

                string text = encoder.GetString(bytes);

                text_ = ImapData.StripQuotes(text, false);
            }
            else
            {
                data_ = bytes;
            }

            if (Updated != null)
            {
                Updated(this, null);
            }

            if (saveLocation_ != null)
            {
                SaveFile(saveCompletion_);
                saveCompletion_ = null;
            }
        }
Пример #3
0
        public void SetValue(string field, string value)
        {
            if (value == "NIL")
            {
                value = "";
            }

            if (field.Equals("subject", StringComparison.CurrentCultureIgnoreCase))
            {
                Subject = value;
            }
            else if (field.Equals("date", StringComparison.CurrentCultureIgnoreCase))
            {
                Sent  = ImapData.ParseDate(value);
                field = "sent";
            }
            else if (field.Equals("received", StringComparison.CurrentCultureIgnoreCase))
            {
                Date  = ImapData.ParseDate(value);
                field = "date";
            }
            else if (field.Equals("uid", StringComparison.CurrentCultureIgnoreCase))
            {
                Uid = Int32.Parse(value);
            }
            else if (field.Equals("size", StringComparison.CurrentCultureIgnoreCase))
            {
                Size = Int32.Parse(value);
            }
            else if (field.Equals("message-id", StringComparison.CurrentCultureIgnoreCase))
            {
                MessageId = value;
            }
        }
Пример #4
0
        public ImapBodyPart(MessageHeader owner, string[] partDesc)
            : base(owner)
        {
            string content = ImapData.StripQuotes(partDesc[0], true).ToLower() + "/" + ImapData.StripQuotes(partDesc[1], true).ToLower();

            ContentType = new ContentType(content);
            Id          = ImapData.StripQuotes(partDesc[3], true);

            int extensionStart = 7;

            if (content.StartsWith("text"))
            {
                extensionStart += 1;
            }
            else if (content.StartsWith("message"))
            {
                extensionStart += 3;
            }

            string[] partParams = ImapData.SplitToken(partDesc[2]);
            if (partParams != null)
            {
                // Final item can't be a match since there must always be a following one
                // with the value in it.
                for (int i = 0; i < partParams.Length - 1; ++i)
                {
                    if (partParams[i].Equals("\"CHARSET\"", StringComparison.OrdinalIgnoreCase))
                    {
                        ContentType.CharSet = ImapData.StripQuotes(partParams[i + 1], true).ToUpper();
                    }
                    else if (partParams[i].Equals("\"NAME\"", StringComparison.OrdinalIgnoreCase))
                    {
                        ContentType.Name = ImapData.StripQuotes(partParams[i + 1], true);
                    }
                }
            }

            Disposition.Size = Int32.Parse(partDesc[6]);

            string encoding = ImapData.StripQuotes(partDesc[5], true);

            if (encoding.Length > 0)
            {
                Encoding = EncodedText.BuildEncoding(encoding);
            }

            if (extensionStart + 1 < partDesc.Length)
            {
                string dispose = partDesc[extensionStart + 1];

                string[] dispData = ImapData.SplitToken(dispose);
                if (dispData != null)
                {
                    if (dispData[0].Equals("\"ATTACHMENT\"", StringComparison.OrdinalIgnoreCase))
                    {
                        Disposition.Inline = false;
                    }

                    string[] dispParams = ImapData.SplitToken(dispData[1]);
                    if (dispParams != null)
                    {
                        // Don't look at the final item as that can't be valid.
                        // Since there always needs to be another entry after 'FILENAME'
                        for (int i = 0; i < dispParams.Length - 1; ++i)
                        {
                            if (dispParams[i].Equals("\"FILENAME\"", StringComparison.OrdinalIgnoreCase))
                            {
                                Disposition.FileName = ImapData.StripQuotes(dispParams[i + 1], true);
                            }
                            else if (dispParams[i].Equals("\"SIZE\"", StringComparison.OrdinalIgnoreCase))
                            {
                                Disposition.Size = Int32.Parse(ImapData.StripQuotes(dispParams[i + 1], true));
                            }
                            else if (dispParams[i].Equals("\"CREATION-DATE\"", StringComparison.OrdinalIgnoreCase))
                            {
                                Disposition.CreationDate = ImapData.ParseDate(ImapData.StripQuotes(dispParams[i + 1], true));
                            }
                            else if (dispParams[i].Equals("\"MODIFICATION-DATE\"", StringComparison.OrdinalIgnoreCase))
                            {
                                Disposition.ModificationDate = ImapData.ParseDate(ImapData.StripQuotes(dispParams[i + 1], true));
                            }
                        }
                    }
                }
            }
        }