private void OnEndOfDataHandler(ReceiveMessageEventSource source, EndOfDataEventArgs e)
        {
            string[] addrs;
            //hash code is not guaranteed to be unique. Add time to fix uniqueness
            string itemId = e.MailItem.GetHashCode().ToString() + e.MailItem.FromAddress.ToString();

            if (this.origToMapping.TryGetValue(itemId, out addrs))
            {
                this.origToMapping.Remove(itemId);
                if (this.databaseConnector != null)
                {
                    this.databaseConnector.LogCatch(addrs[0], addrs[1], e.MailItem.Message.Subject, e.MailItem.Message.MessageId);
                }

                //Add / update orig to header
                if (CatchAllFactory.AppSettings.AddOrigToHeader)
                {
                    MimeDocument mdMimeDoc    = e.MailItem.Message.MimeDocument;
                    HeaderList   hlHeaderlist = mdMimeDoc.RootPart.Headers;
                    Header       origToHeader = hlHeaderlist.FindFirst("X-OrigTo");

                    if (origToHeader == null)
                    {
                        MimeNode   lhLasterHeader = hlHeaderlist.LastChild;
                        TextHeader nhNewHeader    = new TextHeader("X-OrigTo", addrs[0]);
                        hlHeaderlist.InsertBefore(nhNewHeader, lhLasterHeader);
                    }
                    else
                    {
                        origToHeader.Value += ", " + addrs[0];
                    }
                }
            }
        }
Beispiel #2
0
        public static EmailMessage Create(MimeDocument mimeDocument)
        {
            if (mimeDocument == null)
            {
                throw new ArgumentNullException("document");
            }
            if (mimeDocument.RootPart == null)
            {
                throw new ArgumentException(EmailMessageStrings.MimeDocumentRootPartMustNotBeNull);
            }
            MimeTnefMessage mimeTnefMessage = new MimeTnefMessage(mimeDocument);

            return(new EmailMessage(mimeTnefMessage));
        }
Beispiel #3
0
 internal void SetReadOnly(bool makeReadOnly)
 {
     using (ThreadAccessGuard.EnterPublic(this.accessToken))
     {
         MimeDocument mimeDocument = this.MimeDocument;
         if (mimeDocument == null)
         {
             throw new InvalidOperationException("An EmailMessage must be built on a MimeDocument in order to be read-only.");
         }
         if (makeReadOnly != mimeDocument.IsReadOnly)
         {
             this.SetReadOnly(mimeDocument, makeReadOnly, false);
             mimeDocument.SetReadOnlyInternal(makeReadOnly);
         }
     }
 }
Beispiel #4
0
        public static EmailMessage Create(Stream source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
            if (!source.CanRead)
            {
                throw new ArgumentException("Stream must support Read", "source");
            }
            MimeDocument mimeDocument = new MimeDocument();

            mimeDocument.Load(source, CachingMode.Copy);
            MimeTnefMessage mimeTnefMessage = new MimeTnefMessage(mimeDocument);

            return(new EmailMessage(mimeTnefMessage));
        }
Beispiel #5
0
 private void SetReadOnly(MimeDocument parentDocument, bool makeReadOnly, bool isEmbedded)
 {
     using (ThreadAccessGuard.EnterPrivate(this.accessToken))
     {
         if (makeReadOnly)
         {
             if (this.MimeDocument != null)
             {
                 this.MimeDocument.CompleteParse();
             }
             else if (this.RootPart != null)
             {
                 parentDocument.BuildDomAndCompleteParse(this.RootPart);
             }
             List <EmailMessage> list = new List <EmailMessage>(this.Attachments.Count);
             foreach (Attachment attachment in this.Attachments)
             {
                 if (attachment.IsEmbeddedMessage)
                 {
                     EmailMessage embeddedMessage = attachment.EmbeddedMessage;
                     embeddedMessage.SetReadOnly(parentDocument, makeReadOnly, true);
                     list.Add(embeddedMessage);
                 }
             }
             if (list.Count > 0)
             {
                 this.readOnlyEmbeddedMessages = list;
             }
             string mapiMessageClass = this.MapiMessageClass;
             int    num = this.To.Count;
             num += this.Cc.Count;
             num += this.Bcc.Count;
             num += this.ReplyTo.Count;
             Body body = this.Body;
             AttachmentCollection attachments = this.Attachments;
             this.Synchronize();
         }
         else
         {
             this.readOnlyEmbeddedMessages = null;
         }
         this.message.SetReadOnly(makeReadOnly);
     }
 }
Beispiel #6
0
        private bool TryGenerateMessageFromEmlFileData(out string error)
        {
            error = string.Empty;
            MimeDocument mimeDocument = new MimeDocument();

            using (Stream stream = new MemoryStream(this.MessageFileData))
            {
                try
                {
                    mimeDocument.ComplianceMode = MimeComplianceMode.Strict;
                    mimeDocument.Load(stream, CachingMode.Copy);
                    this.message = EmailMessage.Create(mimeDocument);
                }
                catch (ArgumentNullException)
                {
                    return(false);
                }
                catch (ArgumentException)
                {
                    return(false);
                }
                catch (InvalidOperationException)
                {
                    return(false);
                }
                catch (NotSupportedException)
                {
                    return(false);
                }
                catch (MimeException ex)
                {
                    error = ex.Message;
                    return(false);
                }
            }
            if (mimeDocument.ComplianceStatus != MimeComplianceStatus.Compliant)
            {
                error = Strings.MimeDoesNotComplyWithStandards;
                return(false);
            }
            return(true);
        }
Beispiel #7
0
        internal Charset GetDefaultHeaderDecodingCharset(MimeDocument document, MimeNode treeRoot)
        {
            if (treeRoot == null)
            {
                this.GetMimeDocumentOrTreeRoot(out document, out treeRoot);
            }
            Charset charset;

            if (document != null)
            {
                charset = document.EffectiveHeaderDecodingOptions.Charset;
            }
            else
            {
                MimePart mimePart = treeRoot as MimePart;
                charset = ((mimePart == null) ? null : mimePart.FindMimeTreeCharset());
            }
            if (charset == null)
            {
                charset = DecodingOptions.DefaultCharset;
            }
            return(charset);
        }
Beispiel #8
0
 internal void GetMimeDocumentOrTreeRoot(out MimeDocument document, out MimeNode treeRoot)
 {
     document = MimeNode.GetParentDocument(this, out treeRoot);
 }
Beispiel #9
0
 public static void SetDocumentDecodingOptions(MimeDocument mimeDocument, DecodingOptions decodingOptions)
 {
     mimeDocument.HeaderDecodingOptions = decodingOptions;
 }
Beispiel #10
0
 protected override void Dispose(bool disposing)
 {
     if (disposing && document != null) {
         using (ThreadAccessGuard.EnterPublic(document.AccessToken)) {
             document.Flush(badState);
             document = null;
         }
     }
     base.Dispose(disposing);
 }
Beispiel #11
0
 internal MimePartInfo(Charset charset, MimePartInfo.Callback writerCallback, MimePartContentType contentType, AttachmentId attachmentId, MimePart skeletonPart, MimeDocument skeleton, MimePart smimePart, MimeDocument smimeDocument, ref int partIndex)
 {
     this.charset        = charset;
     this.contentType    = contentType;
     this.writerCallback = writerCallback;
     this.partIndex      = partIndex++;
     this.attachmentId   = attachmentId;
     this.skeletonPart   = skeletonPart;
     this.skeleton       = skeleton;
     this.smimePart      = smimePart;
     this.smimeDocument  = smimeDocument;
     this.bodyLines      = -1;
     this.bodyBytes      = -1;
 }
Beispiel #12
0
 public static long GetDocumentPosition(MimeDocument document)
 {
     return(document.Position);
 }
Beispiel #13
0
 public static Stream GetLoadStream(MimeDocument document, bool expectBinaryContent)
 {
     return(document.GetLoadStream(expectBinaryContent));
 }
Beispiel #14
0
 internal MimePartInfo(Charset charset, MimePartInfo.Callback writerCallback, MimePartContentType contentType, AttachmentId attachmentId, MimePart skeletonPart, MimeDocument skeleton, ref int partIndex) : this(charset, writerCallback, contentType, attachmentId, skeletonPart, skeleton, null, null, ref partIndex)
 {
 }
Beispiel #15
0
        void SCPRoutingAgent_OnResolvedMessage(ResolvedMessageEventSource source, QueuedMessageEventArgs e)
        {
            try
            {
                WriteLine("Start SCPRoutingAgent_OnResolvedMessage");

                WriteLine("\tFromAddress: " + e.MailItem.FromAddress.ToString());
                WriteLine("\tSubject: " + e.MailItem.Message.Subject.ToString());
                WriteLine("\tMapiMessageClass: " + e.MailItem.Message.MapiMessageClass.ToString());

                MimeDocument mdMimeDoc    = e.MailItem.Message.MimeDocument;
                HeaderList   hlHeaderlist = mdMimeDoc.RootPart.Headers;
                Header       mhProcHeader = hlHeaderlist.FindFirst("X-SCP");

                if (mhProcHeader == null)
                {
                    WriteLine("\tTouched: " + "No");

                    if (!e.MailItem.Message.IsSystemMessage)
                    {
                        bool touched = false;

                        if (e.MailItem.FromAddress.DomainPart != null)
                        {
                            foreach (EnvelopeRecipient recp in e.MailItem.Recipients)
                            {
                                WriteLine("\t\tFrom: " + e.MailItem.Message.From.SmtpAddress.ToString().ToLower());
                                WriteLine("\t\tTo: " + recp.Address.ToString().ToLower());
                                string[] tmpFrom = e.MailItem.Message.From.SmtpAddress.Split('@');
                                string[] tmpTo   = recp.Address.ToString().Split('@');
                                if (IsMessageBetweenTenants(tmpFrom[1].ToLower(), tmpTo[1].ToLower()))
                                {
                                    WriteLine("\t\tMessage routed to domain: " + tmpTo[1].ToLower() + routingDomain);
                                    RoutingDomain   myRoutingDomain   = new RoutingDomain(tmpTo[1].ToLower() + routingDomain);
                                    RoutingOverride myRoutingOverride = new RoutingOverride(myRoutingDomain, DeliveryQueueDomain.UseOverrideDomain);
                                    source.SetRoutingOverride(recp, myRoutingOverride);
                                    touched = true;
                                }
                            }
                        }
                        else
                        {
                            if ((e.MailItem.Message.MapiMessageClass.ToString() == "IPM.Note.Rules.OofTemplate.Microsoft") &
                                blockInternalInterTenantOOF)
                            {
                                WriteLine("\t\tOOF From: " + e.MailItem.Message.From.SmtpAddress);
                                if (e.MailItem.Message.From.SmtpAddress.Contains("@"))
                                {
                                    string[] tmpFrom = e.MailItem.Message.From.SmtpAddress.Split('@');
                                    foreach (EnvelopeRecipient recp in e.MailItem.Recipients)
                                    {
                                        WriteLine("\t\tTo: " + recp.Address.ToString().ToLower());
                                        string[] tmpTo = recp.Address.ToString().Split('@');
                                        if (IsMessageBetweenTenants(tmpFrom[1].ToLower(), tmpTo[1].ToLower()))
                                        {
                                            WriteLine("\t\tRemove: " + tmpTo[1].ToLower());
                                            e.MailItem.Recipients.Remove(recp);
                                        }
                                    }
                                }
                            }
                        }

                        if (touched)
                        {
                            MimeNode   lhLasterHeader = hlHeaderlist.LastChild;
                            TextHeader nhNewHeader    = new TextHeader("X-SCP", "Logged00");
                            hlHeaderlist.InsertBefore(nhNewHeader, lhLasterHeader);
                        }
                    }
                    else
                    {
                        WriteLine("\tSystem Message");
                    }
                }
                else
                {
                    WriteLine("\tTouched: " + "Yes");
                }
            }

            catch (Exception ex)
            {
                WriteLine("\t[Error] Error :" + ex.Message);
                LogErrorToEventLog("[Error] [OnResolvedMessage] Error :" + ex.Message);
            }

            WriteLine("End SCPRoutingAgent_OnResolvedMessage");
        }
Beispiel #16
0
 public PushStream(MimeDocument document)
 {
     this.document = document;
 }
Beispiel #17
0
 internal static bool IsDocumentReadOnly(MimeDocument document)
 {
     return(document.IsReadOnly);
 }
 internal ImapSmimeMimeProvider(MimePart smimePart, MimeDocument smimeDoc)
 {
     this.smimePart = smimePart;
     this.smimeDoc  = smimeDoc;
 }
Beispiel #19
0
 internal static IImapMimeProvider CreateInstance(MimePart smimePart, MimeDocument smimeDoc)
 {
     return(new ImapSmimeMimeProvider(smimePart, smimeDoc));
 }
Beispiel #20
0
 internal static void SetDocumentReadOnly(MimeDocument document, bool makeReadOnly)
 {
     document.SetReadOnly(makeReadOnly);
 }
Beispiel #21
0
 internal MimeDocumentThreadAccessToken(MimeDocument parent)
 {
 }