Esempio n. 1
0
        public override Server creack(String ip, int port, String username, String password, int timeOut)
        {
            SMTP_Client conn   = null;
            Server      server = new Server();

            try
            {
                conn         = new SMTP_Client();
                conn.Timeout = timeOut;
                conn.Connect(ip, port, false);
                if (conn.IsConnected)
                {
                    conn.EhloHelo(ip);
                    AUTH_SASL_Client_Plain authInfo = new AUTH_SASL_Client_Plain(username, password);
                    conn.Auth(authInfo);
                    if (conn.IsAuthenticated)
                    {
                        server.isSuccess = conn.IsAuthenticated;
                        server.banner    = conn.GreetingText;
                    }
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (conn != null)
                {
                    conn.Disconnect();
                }
            }
            return(server);
        }
Esempio n. 2
0
        public bool Authenticate()
        {
            var musername = mSMTPUsername;

            if (mSMTPUsername != null && mSMTPUsername.IndexOf("@") >= 0)
            {
                musername = mSMTPUsername.Substring(0, mSMTPUsername.IndexOf("@"));
            }

            using (SMTP_Client client = new SMTP_Client())
            {
                try
                {
                    client.Connect(mSMTPServer, mSMTPPort);
                    client.EhloHelo(mSMTPServer);

                    client.Authenticate(musername, mSMTPPassword);

                    return(client.IsAuthenticated);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    client.Disconnect();
                }
            }
        }
Esempio n. 3
0
 public void CreateHost(ConfigHost host)
 {
     Host = new SMTP_Client();
     Host.Connect(host.Server, host.Port, host.EnableSsl);
     Host.EhloHelo(host.Server);
     Host.Auth(Host.AuthGetStrongestMethod(host.Username, host.Password));
 }
Esempio n. 4
0
 /// <summary>
 /// 发送邮件
 /// </summary>
 /// <param name="smtp">Smtp对象</param>
 /// <param name="_strRcpTo">收件地址</param>
 /// <param name="mimeStreams">内存流</param>
 private void SendMail(SMTP_Client smtp, string _strRcpTo, MemoryStream mimeStreams)
 {
     smtp.Connect(this.Smtp, WellKnownPorts.SMTP);
     smtp.EhloHelo(this.Smtp);
     smtp.Authenticate(this.Account, this.CurrentUserMailPassWord);
     smtp.MailFrom(this.CurrentUserMail, -1);
     smtp.RcptTo(_strRcpTo);
     mimeStreams.Position = 0;
     smtp.SendMessage(mimeStreams);
     smtp.Disconnect();
 }
Esempio n. 5
0
        public void SendEmail(Mail mail, Setting setting)
        {
            Mail_Message message = new Mail_Message()
            {
                From      = new Mail_t_MailboxList(),
                Subject   = mail.Subject,             //增加主题
                Priority  = mail.Priority.ToString(), //设置优先级
                MessageID = MIME_Utils.CreateMessageID(),
                Date      = mail.CreatedDateTime
            };

            //增加发件人地址
            message.From.Add(new Mail_t_Mailbox(null, mail.From));
            //增加收件人地址
            mail.To.ForEach(address => message.To.Add(new Mail_t_Mailbox(address, address)));

            //增加邮件内容
            MIME_Entity.CreateEntity_Text_Html("Base64", Encoding.Default, mail.Body);

            //增加附件
            if (mail.Attachments != null && mail.Attachments.Count > 0)
            {
                mail.Attachments.ForEach(attachment =>
                {
                    MIME_Entity.CreateEntity_Attachment(attachment.Name);
                });
            }

            using (SMTP_Client smtpClient = new SMTP_Client())
            {
                //设置SMPT服务地址和端口并连接
                smtpClient.Connect(setting.SmtpHostName, setting.SmtpPort);
                //设置Authentication
                smtpClient.Auth(new LumiSoft.Net.AUTH.AUTH_SASL_Client_Login(setting.User.UserName, setting.User.Password));

                using (MemoryStream stream = new MemoryStream())
                {
                    message.ToStream(stream);
                    stream.Position = 0;
                    //发送邮件
                    smtpClient.SendMessage(stream);
                }
            }
        }
Esempio n. 6
0
        public static bool SendMail(string Body, string Title, string reciveEmail)
        {
            bool sended = false;

            using (SMTP_Client client = new SMTP_Client())
            {
                try
                {
                    //与Pop3服务器建立连接
                    client.Connect(smtp, port, false);
                    client.EhloHelo(smtp);
                    //验证身份
                    var authhh = new AUTH_SASL_Client_Plain(sendEmail, sendPassword);
                    client.Auth(authhh);
                    client.MailFrom(sendEmail, -1);
                    //收件人列表
                    client.RcptTo(reciveEmail);
                    //采用Mail_Message类型的Stream
                    Mail_Message m = Create_PlainText_Html_Attachment_Image(reciveEmail, sendEmail, sendEmail, Title, Body);
                    using (MemoryStream stream = new MemoryStream())
                    {
                        m.ToStream(stream, new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.Q, Encoding.UTF8), Encoding.UTF8);
                        stream.Position = 0;
                        client.SendMessage(stream);
                        sended = true;
                    }
                    if (m != null)
                    {
                        m.Dispose();
                    }
                    client.Disconnect();
                    client.Dispose();
                }
                catch {
                    return(false);
                }
            }
            return(sended);
        }
Esempio n. 7
0
        private Boolean SendMailNew(bool isAsync, object userState)
        {
            string[] mailTos  = mMailTo;
            string[] mailCcs  = mMailCc;
            string[] mailBccs = mMailBcc;
            Dictionary <string, string> attachments = mMailAttachments;

            var toList = new Dictionary <string, string>();

            foreach (var to in MailTo)
            {
                toList.Add(to, to);
            }

            var musername = mSMTPUsername;

            if (mSMTPUsername != null && mSMTPUsername.IndexOf("@") >= 0)
            {
                musername = mSMTPUsername.Substring(0, mSMTPUsername.IndexOf("@"));
            }

            bool checkspmail = CheckSpecialMail(toList);

            if (!checkspmail && MailCc != null)
            {
                checkspmail = CheckSpecialMail(MailCc);
            }
            if (checkspmail)
            {
                foreach (string address in toList.Keys)
                {
                    using (SMTP_Client client = new SMTP_Client())
                    {
                        client.Timeout = this.Timeout;
                        client.Connect(mSMTPServer, mSMTPPort);
                        client.EhloHelo(mSMTPServer);


                        client.Authenticate(musername, mSMTPPassword);
                        client.MailFrom(mMailFrom, -1);
                        client.RcptTo(address);


                        Mail_Message m = Create_PlainText_Html_Attachment_Image(toList, new Dictionary <string, string>()
                                                                                , mMailFrom,
                                                                                mMailFrom, MailSubject, mMailBody, attachments, "", "", CheckSpecialMail(new string[] { address }));

                        try
                        {
                            using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                            {
                                m.ToStream(stream, new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.Q, Encoding.UTF8), Encoding.UTF8);
                                stream.Position = 0;
                                client.SendMessage(stream);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw ex;
                        }

                        if (m != null)
                        {
                            m.Dispose();
                        }

                        client.Disconnect();
                    }
                }
                return(true);
            }
            else
            {
                using (SMTP_Client client = new SMTP_Client())
                {
                    client.Timeout = this.Timeout;
                    client.Connect(mSMTPServer, mSMTPPort);
                    client.EhloHelo(mSMTPServer);
                    AUTH_SASL_Client authhh = client.AuthGetStrongestMethod(musername, mSMTPPassword);
                    client.Auth(authhh);
                    client.MailFrom(mMailFrom, -1);
                    foreach (string address in toList.Keys)
                    {
                        client.RcptTo(address);
                    }



                    Mail_Message m = Create_PlainText_Html_Attachment_Image(toList, new Dictionary <string, string>()
                                                                            , mMailFrom,
                                                                            mMailFrom, MailSubject, mMailBody, attachments, "", "", false);

                    try
                    {
                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                        {
                            m.ToStream(stream, new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.Q, Encoding.UTF8), Encoding.UTF8);
                            stream.Position = 0;
                            client.SendMessage(stream);
                        }


                        return(true);
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        if (m != null)
                        {
                            m.Dispose();
                        }
                        client.Disconnect();
                    }
                }
            }
        }
        public void Send(ChannelMessage message)
        {
            var creds = CredentialsProvider.GetCredentials().ToNetworkCredential();

            Mail_Message msg = new Mail_Message();

            msg.MimeVersion = "1.0";
            msg.MessageID   = MIME_Utils.CreateMessageID();
            msg.Subject     = message.Context;
            msg.From        = message.From.ToMailBoxList();
            msg.ReplyTo     = message.ReturnTo == null?
                              message.From.ToAddressList() : message.ReturnTo.ToAddressList();

            if (String.IsNullOrEmpty(message.InReplyTo) == false)
            {
                msg.InReplyTo = message.InReplyTo;
            }

            msg.To = new Mail_t_AddressList();
            foreach (var address in message.To)
            {
                msg.To.Add(address.ToMailBox());
            }

            msg.Cc = new Mail_t_AddressList();
            foreach (var address in message.CC)
            {
                msg.Cc.Add(address.ToMailBox());
            }

            //--- multipart/mixed -------------------------------------------------------------------------------------------------
            MIME_h_ContentType contentType_multipartMixed = new MIME_h_ContentType(MIME_MediaTypes.Multipart.mixed);

            contentType_multipartMixed.Param_Boundary = Guid.NewGuid().ToString().Replace('-', '.');
            MIME_b_MultipartMixed multipartMixed = new MIME_b_MultipartMixed(contentType_multipartMixed);

            msg.Body = multipartMixed;

            //--- multipart/alternative -----------------------------------------------------------------------------------------
            MIME_Entity        entity_multipartAlternative      = new MIME_Entity();
            MIME_h_ContentType contentType_multipartAlternative = new MIME_h_ContentType(MIME_MediaTypes.Multipart.alternative);

            contentType_multipartAlternative.Param_Boundary = Guid.NewGuid().ToString().Replace('-', '.');
            MIME_b_MultipartAlternative multipartAlternative = new MIME_b_MultipartAlternative(contentType_multipartAlternative);

            entity_multipartAlternative.Body = multipartAlternative;
            multipartMixed.BodyParts.Add(entity_multipartAlternative);

            //--- text/plain ----------------------------------------------------------------------------------------------------
            MIME_Entity entity_text_plain = new MIME_Entity();
            MIME_b_Text text_plain        = new MIME_b_Text(MIME_MediaTypes.Text.plain);

            entity_text_plain.Body = text_plain;
            // Add text body if there is any
            if (message.BodyText != null && message.BodyText.Length > 0)
            {
                var bodyText = message.BodyText.ReadString();

                // Make sure there is a newline at the end of our text, otherwise it will screw up
                // our multipart data format
                if (!bodyText.EndsWith(Environment.NewLine))
                {
                    bodyText = bodyText + Environment.NewLine;
                }

                text_plain.SetText(MIME_TransferEncodings.SevenBit, Encoding.UTF8, bodyText);
            }

            multipartAlternative.BodyParts.Add(entity_text_plain);

            //--- text/html ------------------------------------------------------------------------------------------------------
            MIME_Entity entity_text_html = new MIME_Entity();
            MIME_b_Text text_html        = new MIME_b_Text(MIME_MediaTypes.Text.html);

            entity_text_html.Body = text_html;
            if (message.BodyHtml != null && message.BodyHtml.Length > 0)
            {
                var bodyHtml = message.BodyHtml.ReadString();

                // Make sure there is a newline at the end of our text, otherwise it will screw up
                // our multipart data format
                if (!bodyHtml.EndsWith(Environment.NewLine))
                {
                    bodyHtml = bodyHtml + Environment.NewLine;
                }

                text_html.SetText(MIME_TransferEncodings.SevenBit, Encoding.UTF8, bodyHtml);
            }

            multipartAlternative.BodyParts.Add(entity_text_html);

            foreach (var channelAttachment in message.Attachments)
            {
                MIME_b_Application attachmentBody = new MIME_b_Application(MIME_MediaTypes.Application.octet_stream);
                MIME_Entity        attachment     = new MIME_Entity();
                attachment.Body = attachmentBody;

                // Has to happen before the following lines of code
                multipartMixed.BodyParts.Add(attachment);

                attachment.ContentType            = new MIME_h_ContentType(MimeHelper.GetMimeType(channelAttachment.Filename));
                attachment.ContentType.Param_Name = channelAttachment.Filename;

                MIME_h_ContentDisposition contentDisposition = new MIME_h_ContentDisposition(DispositionTypeNames.Attachment);
                contentDisposition.Param_FileName = channelAttachment.Filename;

                attachment.ContentDisposition      = contentDisposition;
                attachment.ContentTransferEncoding = TransferEncoding.Base64.ToString();

                attachmentBody.SetData(channelAttachment.ContentStream, MIME_TransferEncodings.Base64);
            }

            // Inject headers
            if (!String.IsNullOrEmpty(message.MessageIdentifier))
            {
                msg.Header.Add(new MIME_h_Unstructured("x-i2mp-messageid", message.MessageIdentifier));
            }

            //if (!String.IsNullOrEmpty(message.Metadata.i2mpFlow))
            //    msg.Header.Add(new MIME_h_Unstructured("x-i2mp-flow", message.Metadata.i2mpFlow));

            //if (!String.IsNullOrEmpty(message.Metadata.i2mpReference))
            //    mailMessage.Headers.Add("X-i2mp-ref", message.Metadata.i2mpReference);

            //if (!String.IsNullOrEmpty(message.Metadata.i2mpSequence))
            //    mailMessage.Headers.Add("X-i2mp-seq", message.Metadata.i2mpSequence);

            //if (!String.IsNullOrEmpty(message.Metadata.i2mpRelation))
            //    mailMessage.Headers.Add("X-i2mp-rel", message.Metadata.i2mpRelation);

            //if (!String.IsNullOrEmpty(message.Metadata.i2mpRelationId))
            //    mailMessage.Headers.Add("X-i2mp-rel-id", message.Metadata.i2mpRelationId);


            // Send message
            try
            {
                SMTP_Client client = new SMTP_Client();

                if ("/Settings/Channels/LoggerEnabled".AsKey(false))
                {
                    client.Logger = new LumiSoft.Net.Log.Logger();
                }

                // todo push this logic into the smtp client implementation itself
                if (Hostname == "smtp.live.com")
                {
                    // Hack for hotmail, first do a connect with no secured channel,
                    // then a STARTTLS
                    client.Connect(Hostname, Port, false);
                    client.StartTLS();
                }
                else
                {
                    client.Connect(Hostname, Port, IsSecured);
                }

                client.Authenticate(creds.UserName, creds.Password);

                using (MemoryStream ms = new MemoryStream())
                {
                    client.MailFrom(msg.From[0].Address, -1);

                    msg.ToStream(ms,
                                 new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.Q, Encoding.UTF8), Encoding.UTF8);

                    // Reset stream
                    ms.Seek(0, SeekOrigin.Begin);

                    foreach (var address in message.To)
                    {
                        client.RcptTo(address.Address);
                    }

                    foreach (var address in message.CC)
                    {
                        client.RcptTo(address.Address);
                    }

                    foreach (var address in message.BCC)
                    {
                        client.RcptTo(address.Address);
                    }

                    try
                    {
                        client.SendMessage(ms);
                    }
                    finally
                    {
                        client.Dispose();
                    }
                }
            }
            catch (SmtpFailedRecipientsException e)
            {
                throw new ChannelFunctionalException(e.Message, e)
                      {
                          DoNotRetry = true
                      };
            }
            catch (SmtpException e)
            {
                throw new ChannelFunctionalException(e.Message, e);
            }
            catch (Exception e)
            {
                throw new ChannelFunctionalException(e.Message, e);
            }
        }