All geek questions in one place

Send SMTP mail from Gmail, live, aol or yahoo accounts when my computer is connected through a proxy server or without a proxy server on the Internet

I want to send email to C # via SMTP to other mail providers, for example Gmail, Yahoo, AOL, Msn, Live, etc., so that my code works fine if my computer is connected to the Internet through a proxy or connected directly to the Internet . (A proxy is a direct proxy server that accepts requests from the internal network and sends them to the Internet, and I configure the proxy server in IE as)
    .................... .............

I have a code by which I can send SMTP mail if the PC is not connected through a proxy

    public void SendMail(string senderId, string password, List<string> To, List<string> CC, List<string> BCC, string Subject, string Body, List<Attachment> Attachment)
    {
        SmtpClient SmtpServer = null;
        string[] ss = senderId.Split('@');

        string ServerName = ss[1].Substring(0, ss[1].IndexOf("."));

        switch (ServerName.ToLower())
        {
            case "gmail":
                SmtpServer = new SmtpClient("smtp.gmail.com");
                SmtpServer.Port = 587;
                SmtpServer.Credentials = new System.Net.NetworkCredential(senderId, password);
                SmtpServer.EnableSsl = true;
                break;
            case "msn":
            case "live":
            case "hotmail":
            case "outlook":
                SmtpServer = new SmtpClient("smtp.live.com");
                SmtpServer.Port = 25;
                SmtpServer.Credentials = new System.Net.NetworkCredential(senderId, password);
                SmtpServer.EnableSsl = true;
                break;

            case "aol":
                SmtpServer = new SmtpClient("smtp.aol.com");
                SmtpServer.Port = 25;
                SmtpServer.Credentials = new System.Net.NetworkCredential(senderId, password);
                SmtpServer.EnableSsl = true;
                break;
            case "yahoo":
            case "ymail":
            case "rocketmail":
            case "yahoomail":
                SmtpServer = new SmtpClient("smtp.mail.yahoo.com");
                SmtpServer.Port = 25;
                SmtpServer.Credentials = new System.Net.NetworkCredential(senderId, password);
                SmtpServer.EnableSsl = false;
                break;
            default:

                break;


        }
        SmtpServer.DeliveryMethod = SmtpDeliveryMethod.Network;

        MailMessage mail = new MailMessage();
        mail.From = new MailAddress(senderId);

        foreach (string item in To)
        {
            mail.To.Add(item);
        }
        foreach (string item in CC)
        {
            mail.CC.Add(item);
        }
        foreach (string item in BCC)
        {
            mail.Bcc.Add(item);
        }

        mail.Subject = Subject;
        mail.Body = Body;

        foreach (Attachment item in Attachment)
        {
            mail.Attachments.Add(item);
        }

        SmtpServer.Send(mail);

    }

This works fine, but I want to send an email when connecting through a proxy.

, -
ASP.net SMTP Mail -
.NET PROXY?
, , chilkat, limilabs, , -.
, SOCKS, , SMTP , -, .
- , , -, - , ?

EDIT: - , , Chilkat limilabs, > dll

+2
1

- , , .

, , .

, SmtpServer , ,

   #region ..... SOCKET MAIL .....

    private enum SMTPResponse : int
    {
        /// <summary>
        /// 220
        /// </summary>
        CONNECT_SUCCESS = 220,
        /// <summary>
        /// 235
        /// </summary>
        CRED_SUCCESS = 235,
        /// <summary>
        /// 250
        /// </summary>
        GENERIC_SUCCESS = 250,
        /// <summary>
        /// 334
        /// </summary>
        AUTH_SUCCESS = 334,
        /// <summary>
        /// 354
        /// </summary>
        DATA_SUCCESS = 354,
        /// <summary>
        /// 221
        /// </summary>
        QUIT_SUCCESS = 221
    }

    public static string EncodeTo64(string toEncode)
    {

        byte[] toEncodeAsBytes = System.Text.Encoding.ASCII.GetBytes(toEncode);

        string returnValue = System.Convert.ToBase64String(toEncodeAsBytes, Base64FormattingOptions.None);

        return returnValue;

    }

    public bool SendFromSocket(MailMessage message)
    {
        var requestUri = new System.Uri("smtps://" +SmtpServer.Host +":"+SmtpServer.Port);

        Uri proxy = null;
        //This is magic code which does your job for the proxy 
        using (var web = new System.Net.WebClient())
        {                
            proxy = web.Proxy.GetProxy(requestUri);                
        }

        using (var s = new TcpClient(proxy.DnsSafeHost, proxy.Port  ))
        {               
            using (var stream = s.GetStream())
            using (var clearTextReader = new StreamReader(stream))
            using (var clearTextWriter = new StreamWriter(stream) { AutoFlush = true })
            using (var sslStream = new SslStream(stream))
            {
                if (!Check_Response(clearTextReader, SMTPResponse.CONNECT_SUCCESS))
                {
                    s.Close();
                    return false;
                }

                clearTextWriter.WriteLine("HELO");
                if (!Check_Response(clearTextReader, SMTPResponse.GENERIC_SUCCESS))
                {
                    s.Close();
                    return false;
                }

                clearTextWriter.WriteLine("STARTTLS");
                if (!Check_Response(clearTextReader, SMTPResponse.CONNECT_SUCCESS))
                {
                    s.Close();
                    return false;
                }


                sslStream.AuthenticateAsClient(SmtpServer.Host);
                bool flag = sslStream.IsAuthenticated;

                using (var reader = new StreamReader(sslStream))
                using (var writer = new StreamWriter(sslStream) { AutoFlush = true })
                {                       
                    writer.WriteLine(string.Format("EHLO {0}", SmtpServer.Host));
                    if (!Check_Response(reader, SMTPResponse.GENERIC_SUCCESS))
                    {
                        s.Close();
                        return false;
                    }

                    writer.WriteLine("AUTH LOGIN");
                    if (!Check_Response(reader, SMTPResponse.AUTH_SUCCESS))
                    {
                        s.Close();
                        return false;
                    }

                    writer.WriteLine(EncodeTo64(SenderId));
                    if (!Check_Response(reader, SMTPResponse.AUTH_SUCCESS))
                    {
                        s.Close();
                        return false;
                    }

                    writer.WriteLine(EncodeTo64(Password));
                    if (!Check_Response(reader, SMTPResponse.CRED_SUCCESS))
                    {
                        s.Close();
                        return false;
                    }

                    writer.WriteLine("MAIL FROM: <{0}>", message.From);
                    if (!Check_Response(reader, SMTPResponse.GENERIC_SUCCESS))
                    {

                        s.Close();
                        return false;
                    }

                    foreach (MailAddress To in message.To)
                    {
                        writer.WriteLine("RCPT TO: <{0}>", To.Address);
                        if (!Check_Response(reader, SMTPResponse.GENERIC_SUCCESS))
                        {
                            s.Close();
                            return false;
                        }
                    }

                    if (message.CC != null)
                    {
                        foreach (MailAddress cc in message.CC)
                        {
                            writer.WriteLine(string.Format("RCPT TO: <{0}>", cc.Address));
                            if (!Check_Response(reader, SMTPResponse.GENERIC_SUCCESS))
                            {
                                s.Close();
                                return false;
                            }
                        }
                    }

                    StringBuilder Header = new StringBuilder();
                    Header.Append("From: " + message.From + "\r\n");
                    Header.Append("To: ");
                    for (int i = 0; i < message.To.Count; i++)
                    {
                        Header.Append(i > 0 ? "," : "");
                        Header.Append(message.To[i].Address);
                    }
                    Header.Append("\r\n");
                    if (message.CC != null)
                    {
                        Header.Append("Cc: ");
                        for (int i = 0; i < message.CC.Count; i++)
                        {
                            Header.Append(i > 0 ? "," : "");
                            Header.Append(message.CC[i].Address);
                        }
                        Header.Append("\r\n");
                    }
                    Header.Append("Date: ");
                    Header.Append(DateTime.Now.ToString("ddd, d M y H:m:s z"));
                    Header.Append("\r\n");
                    Header.Append("Subject: " + message.Subject + "\r\n");
                    Header.Append("X-Mailer: SMTPDirect v1\r\n");
                    string MsgBody = message.Body;
                    if (!MsgBody.EndsWith("\r\n"))
                        MsgBody += "\r\n";
                    if (message.Attachments.Count > 0)
                    {
                        Header.Append("MIME-Version: 1.0\r\n");
                        Header.Append("Content-Type: multipart/mixed; boundary=unique-boundary-1\r\n");
                        Header.Append("\r\n");
                        Header.Append("This is a multi-part message in MIME format.\r\n");
                        StringBuilder sb = new StringBuilder();
                        sb.Append("--unique-boundary-1\r\n");
                        sb.Append("Content-Type: text/plain\r\n");
                        sb.Append("Content-Transfer-Encoding: 7Bit\r\n");
                        sb.Append("\r\n");
                        sb.Append(MsgBody + "\r\n");
                        sb.Append("\r\n");

                        foreach (object o in message.Attachments)
                        {
                            Attachment a = o as Attachment;
                            byte[] binaryData;
                            if (a != null)
                            {
                                //FileInfo f = new FileInfo(a.);
                                sb.Append("--unique-boundary-1\r\n");
                                sb.Append("Content-Type: application/octet-stream; file=" + a.Name + "\r\n");
                                sb.Append("Content-Transfer-Encoding: base64\r\n");
                                sb.Append("Content-Disposition: attachment; filename=" + a.Name + "\r\n");
                                sb.Append("\r\n");
                                Stream fs = a.ContentStream;
                                binaryData = new Byte[fs.Length];
                                long bytesRead = fs.Read(binaryData, 0, (int)fs.Length);
                                fs.Close();
                                string base64String = System.Convert.ToBase64String(binaryData, 0, binaryData.Length);

                                for (int i = 0; i < base64String.Length; )
                                {
                                    int nextchunk = 100;
                                    if (base64String.Length - (i + nextchunk) < 0)
                                        nextchunk = base64String.Length - i;
                                    sb.Append(base64String.Substring(i, nextchunk));
                                    sb.Append("\r\n");
                                    i += nextchunk;
                                }
                                sb.Append("\r\n");
                            }
                        }
                        MsgBody = sb.ToString();
                    }

                    writer.WriteLine("DATA\r\n");
                    if (!Check_Response(reader, SMTPResponse.DATA_SUCCESS))
                    {
                        s.Close();
                        return false;
                    }
                    Header.Append("\r\n");
                    Header.Append(MsgBody);
                    Header.Append(".\r\n");
                    Header.Append("\r\n");
                    Header.Append("\r\n");
                    writer.WriteLine(Header.ToString());
                    if (!Check_Response(reader, SMTPResponse.GENERIC_SUCCESS))
                    {
                        s.Close();
                        return false;
                    }

                    writer.WriteLine("QUIT\r\n");
                    Check_Response(reader, SMTPResponse.QUIT_SUCCESS);
                    s.Close();
                    return true;
                }
            }

        }
    }

    private static bool Check_Response(StreamReader netStream, SMTPResponse response_expected)
    {

        int response;

        int read = 0;

        StringBuilder sResponse = new StringBuilder();
        do
        {
            char[] buffer = new char[1024];                
            read = netStream.Read(buffer, 0, buffer.Length);
            sResponse.Append(buffer);                
        }
        while (read == 1024);

        response = Convert.ToInt32(sResponse.ToString().Substring(0, 3));

        if (response != (int)response_expected)
            return false;
        return true;
    }

    #endregion ..... SOCKET MAIL .....
+3

Source: https://habr.com/ru/post/1741208/

More articles:


All Articles