c++实现smtp发送邮件,支持ssl的465端口发送,支持附件、一次发送多人、抄送等

这篇具有很好参考价值的文章主要介绍了c++实现smtp发送邮件,支持ssl的465端口发送,支持附件、一次发送多人、抄送等。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前言

c++实现smtp发送邮件,支持ssl的465端口发送,支持附件、一次发送多人、抄送等。
这里只使用了openssl库(用来支持ssl的465端口),其他部分是原生c++,支持在win/linux运行。
网上很多都是原始的支持25端口,明文发送,这里介绍一下ssl思路

实现思路

使用sockect编程和ssl,使用SMTP协议。
使用了c++的多态语言特性,包括重载和虚函数。
文中给出mail.h 和mail.cpp 以及main.cpp部分测试代码
Linux安装openssl

sudo apt install libssl-dev

win下自行下载安装

SMTP协议简介

SMTP协议的定义:

1、SMTP 是一种TCP协议支持的提供可靠且有效电子邮件传输的应用层协议;
2、SMTP 是建立在 TCP上的一种邮件服务,主要用于传输系统之间的邮件信息并提供来信有关的通知;
3、SMTP 独立于特定的传输子系统,且只需要可靠有序的数据流信道支持;
4、SMTP 重要特性之一是其能跨越网络传输邮件,即“ SMTP 邮件中继”;
5、SMTP是一个相对简单的基于文本的协议。

SMTP基本命令

SMTP基本命令包括以下几个:HELO﹑EHLO、MAIL﹑RCPT﹑DATA、AUTH LOGIN和QUIT
1、HELO–发件方问候收件方,后面是发件人的服务器地址或标识。收件方回答OK时标识自己的身份。问候和确认过程表明两台机器可以进行通信,同时状态参量被复位,缓冲区被清空。
EHLO–申明身份,表示自己身份需要验证,注意这部分需要通过Telnet验证一下,是user@example.com还是user,否则会出错。
2、MAIL–这个命令用来开始传送邮件,它的后面跟随发件方邮件地址(返回邮件地址)。它也用来当邮件无法送达时,发送失败通知。为保证邮件的成功发送,发件方的地址应是被对方或中间转发方同意接受的。这个命令会清空有关的缓冲区,为新的邮件做准备。
3、RCPT –这个命令告诉收件方收件人的邮箱。当有多个收件人时,需要多次使用该命令RCPT
4、TO,每次只能指明一个人。如果接收方服务器不同意转发这个地址的邮件,它必须报550错误代码通知发件方。如果服务器同意转发,它要更改邮件发送路径,把最开始的目的地(该服务器)换成下一个服务器。
5、DATA–收件方把该命令之后的数据作为发送的数据。数据被加入数据缓冲区中,以单独一行是”.”的行结束数据。结束行对于接收方同时意味立即开始缓冲区内的数据传送,传送结束后清空缓冲区。如果传送接受,接收方回复OK。
6、QUIT–SMTP要求接收放必须回答OK,然后中断传输;在收到这个命令并回答OK前,收件方不得中断连接,即使传输出现错误。发件方在发出这个命令并收到OK答复前,也不得中断连接。
7、AUTH LOGIN–登录邮箱,这一部分一般要用base64加密。

头文件mail.h

#pragma once
#include <string>
#include <vector>
#include <map>

#include <openssl/ossl_typ.h>

#ifndef WIN32
#include<netdb.h>
#endif

class SmtpBase
{
protected:
    struct EmailInfo
    {
        std::string smtpServer;      //the SMTP server
        std::string serverPort;      //the SMTP server port
        std::string charset;         //the email character set
        std::string sender;          //the sender's name
        std::string senderEmail;     //the sender's email
        std::string password;        //the password of sender
        std::string recipient;       //the recipient's name
        std::string recipientEmail;  //the recipient's email

        std::map<std::string, std::string> recvList; //收件人列表<email, name>

        std::string subject;         //the email message's subject  邮件主题
        std::string message;         //the email message body   邮件内容

        std::map<std::string, std::string> ccEmail;         //抄送列表
        std::vector<std::string> attachment; //附件
    };
public:

    virtual ~SmtpBase() {}
    /**
     * @brief 简单发送文本邮件
     * @param   from 发送者的帐号
     * @param   passs 发送者密码
     * @param   to 收件人
     * @param   subject 主题
     * @param   strMessage  邮件内容
     */

    virtual int SendEmail(const std::string& from, const std::string& passs, const std::string& to, const std::string& subject, const std::string& strMessage) = 0;
    /**
     * @brief 发送邮件,包括附件以及抄送人和多个收件人
     * @param   from 发送者的帐号
     * @param   passs 发送者密码
     * @param   vecTo 收件人列表
     * @param   subject 主题
     * @param   strMessage  邮件内容
     * @param   attachment  附件列表    附件可以是绝对路径,默认是可执行程序目录下
     * @param   ccList  抄送列表
     */
    virtual int SendEmail(const std::string& from, const std::string& passs, const std::vector<std::string>& vecTo,
        const std::string& subject, const std::string& strMessage, const std::vector<std::string>& attachment,const std::vector<std::string>& ccList) = 0;

    std::string GetLastError()
    {
        return m_lastErrorMsg;
    }

    virtual int Read(void* buf, int num) = 0;
    virtual int Write(const void* buf, int num) = 0;
    virtual int Connect() = 0;
    virtual int DisConnect() = 0;

protected:

    std::string m_lastErrorMsg;


};


class SmtpEmail : public SmtpBase
{

public:
    SmtpEmail(const std::string& emailHost, const std::string& port);
    ~SmtpEmail();

    int SendEmail(const std::string& from, const std::string& passs, const std::string& to, const std::string& subject, const std::string& strMessage);

    int SendEmail(const std::string& from, const std::string& passs, const std::vector<std::string>& vecTo,
        const std::string& subject, const std::string& strMessage, const std::vector<std::string>& attachment, const std::vector<std::string>& ccList);
protected:
    int Read(void* buf, int num);
    int Write(const void* buf, int num);
    int Connect();
    int DisConnect();

    virtual std::string GetEmailBody(const EmailInfo & info);
private:
    //int SMTPSSLComunicate(SSL *connection, const EmailInfo &info);
    int SMTPComunicate(const EmailInfo &info);




protected:
    addrinfo* m_addrinfo;
    int m_socketfd;

    std::string m_host;
    std::string m_port;

    bool m_isConnected;
};

class SimpleSmtpEmail : public SmtpEmail
{
public:
    using SmtpEmail::SmtpEmail;
    virtual std::string GetEmailBody(const EmailInfo & info);
};

class SslSmtpEmail : public SmtpEmail
{
public:
    using SmtpEmail::SmtpEmail;
    ~SslSmtpEmail();

    int Connect();
    int DisConnect();
protected:
    int Read(void* buf, int num);
    int Write(const void* buf, int num);
private:
    SSL_CTX *m_ctx;
    SSL *m_ssl;
};

class SimpleSslSmtpEmail : public SslSmtpEmail
{
public:
    using SslSmtpEmail::SslSmtpEmail;
    virtual std::string GetEmailBody(const EmailInfo & info);
};

实现文件mail.cpp

#ifdef WIN32
#include <WinSock2.h>
#endif
#include "mail.h"
#include <fstream>
#include <sstream>
#include <iostream>
#include <string.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#ifdef WIN32
#include <WinSock2.h>
#include <WS2tcpip.h>
#pragma comment(lib, "ws2_32.lib")
#else 
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#define INVALID_SOCKET -1
#endif

template<typename T>
std::string join(T& vecData, const std::string& delim)
{
    if (vecData.size() <= 0)
    {
        return std::string();
    }
    std::stringstream ss;
    for (auto& item : vecData)
    {
        ss << delim  << item ;
    }

    return ss.str().substr(delim.length());
}

const char MimeTypes[][2][128] =
{
    { "***",    "application/octet-stream" },
    { "csv",    "text/csv" },
    { "tsv",    "text/tab-separated-values" },
    { "tab",    "text/tab-separated-values" },
    { "html",    "text/html" },
    { "htm",    "text/html" },
    { "doc",    "application/msword" },
    { "docx",    "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
    { "ods",    "application/x-vnd.oasis.opendocument.spreadsheet" },
    { "odt",    "application/vnd.oasis.opendocument.text" },
    { "rtf",    "application/rtf" },
    { "sxw",    "application/vnd.sun.xml.writer" },
    { "txt",    "text/plain" },
    { "xls",    "application/vnd.ms-excel" },
    { "xlsx",    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
    { "pdf",    "application/pdf" },
    { "ppt",    "application/vnd.ms-powerpoint" },
    { "pps",    "application/vnd.ms-powerpoint" },
    { "pptx",    "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
    { "wmf",    "image/x-wmf" },
    { "atom",    "application/atom+xml" },
    { "xml",    "application/xml" },
    { "json",    "application/json" },
    { "js",    "application/javascript" },
    { "ogg",    "application/ogg" },
    { "ps",    "application/postscript" },
    { "woff",    "application/x-woff" },
    { "xhtml","application/xhtml+xml" },
    { "xht",    "application/xhtml+xml" },
    { "zip",    "application/zip" },
    { "gz",    "application/x-gzip" },
    { "rar",    "application/rar" },
    { "rm",    "application/vnd.rn-realmedia" },
    { "rmvb",    "application/vnd.rn-realmedia-vbr" },
    { "swf",    "application/x-shockwave-flash" },
    { "au",        "audio/basic" },
    { "snd",    "audio/basic" },
    { "mid",    "audio/mid" },
    { "rmi",        "audio/mid" },
    { "mp3",    "audio/mpeg" },
    { "aif",    "audio/x-aiff" },
    { "aifc",    "audio/x-aiff" },
    { "aiff",    "audio/x-aiff" },
    { "m3u",    "audio/x-mpegurl" },
    { "ra",    "audio/vnd.rn-realaudio" },
    { "ram",    "audio/vnd.rn-realaudio" },
    { "wav",    "audio/x-wave" },
    { "wma",    "audio/x-ms-wma" },
    { "m4a",    "audio/x-m4a" },
    { "bmp",    "image/bmp" },
    { "gif",    "image/gif" },
    { "jpe",    "image/jpeg" },
    { "jpeg",    "image/jpeg" },
    { "jpg",    "image/jpeg" },
    { "jfif",    "image/jpeg" },
    { "png",    "image/png" },
    { "svg",    "image/svg+xml" },
    { "tif",    "image/tiff" },
    { "tiff",    "image/tiff" },
    { "ico",    "image/vnd.microsoft.icon" },
    { "css",    "text/css" },
    { "bas",    "text/plain" },
    { "c",        "text/plain" },
    { "h",        "text/plain" },
    { "rtx",    "text/richtext" },
    { "mp2",    "video/mpeg" },
    { "mpa",    "video/mpeg" },
    { "mpe",    "video/mpeg" },
    { "mpeg",    "video/mpeg" },
    { "mpg",    "video/mpeg" },
    { "mpv2",    "video/mpeg" },
    { "mov",    "video/quicktime" },
    { "qt",    "video/quicktime" },
    { "lsf",    "video/x-la-asf" },
    { "lsx",    "video/x-la-asf" },
    { "asf",    "video/x-ms-asf" },
    { "asr",    "video/x-ms-asf" },
    { "asx",    "video/x-ms-asf" },
    { "avi",    "video/x-msvideo" },
    { "3gp",    "video/3gpp" },
    { "3gpp",    "video/3gpp" },
    { "3g2",    "video/3gpp2" },
    { "movie","video/x-sgi-movie" },
    { "mp4",    "video/mp4" },
    { "wmv",    "video/x-ms-wmv" },
    { "webm","video/webm" },
    { "m4v",    "video/x-m4v" },
    { "flv",    "video/x-flv" }
};


std::string fileBasename(const std::string path) 
{
    std::string filename = path.substr(path.find_last_of("/\\") + 1);//解析出文件名字
    return filename;
}

std::string getFileContents(const char *filename)
{
    std::ifstream in(filename, std::ios::in | std::ios::binary);
    if (in)
    {
        std::string contents;
        in.seekg(0, std::ios::end);
        contents.resize(in.tellg());
        in.seekg(0, std::ios::beg);
        in.read(&contents[0], contents.size());
        in.close();
        return(contents);
    }
    else {
        printf("文件读取失败:%s\n",filename);
        return "";
    }
}
//获取文件的后缀名 如xxx.jpg 获取的是jpg
std::string GetFileExtension(const std::string& FileName)
{
    if (FileName.find_last_of(".") != std::string::npos)        //find_last_of逆向查找在原字符串中最后一个与指定字符串(或字符)中的某个字符匹配的字符,返回它的位置。若查找失败,则返回npos。
        return FileName.substr(FileName.find_last_of(".") + 1);
    return "";
}

const char* GetMimeTypeFromFileName(char* szFileExt)
{
    for (unsigned int i = 0; i < sizeof(MimeTypes) / sizeof(MimeTypes[0]); i++)
    {
        if (strcmp(MimeTypes[i][0], szFileExt) == 0)
        {
            return MimeTypes[i][1];
        }
    }
    return MimeTypes[0][1];   //if does not match any,  "application/octet-stream" is returned
}

char* base64Encode(char const* origSigned, unsigned origLength)
{
    static const char base64Char[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    unsigned char const* orig = (unsigned char const*)origSigned; // in case any input bytes have the MSB set
    if (orig == NULL) return NULL;

    unsigned const numOrig24BitValues = origLength / 3;
    bool havePadding = origLength > numOrig24BitValues * 3;
    bool havePadding2 = origLength == numOrig24BitValues * 3 + 2;
    unsigned const numResultBytes = 4 * (numOrig24BitValues + havePadding);
    char* result = new char[numResultBytes + 3]; // allow for trailing '/0'

    // Map each full group of 3 input bytes into 4 output base-64 characters:
    unsigned i;
    for (i = 0; i < numOrig24BitValues; ++i)
    {
        result[4 * i + 0] = base64Char[(orig[3 * i] >> 2) & 0x3F];
        result[4 * i + 1] = base64Char[(((orig[3 * i] & 0x3) << 4) | (orig[3 * i + 1] >> 4)) & 0x3F];
        result[4 * i + 2] = base64Char[((orig[3 * i + 1] << 2) | (orig[3 * i + 2] >> 6)) & 0x3F];
        result[4 * i + 3] = base64Char[orig[3 * i + 2] & 0x3F];
    }

    // Now, take padding into account.  (Note: i == numOrig24BitValues)
    if (havePadding)
    {
        result[4 * i + 0] = base64Char[(orig[3 * i] >> 2) & 0x3F];
        if (havePadding2)
        {
            result[4 * i + 1] = base64Char[(((orig[3 * i] & 0x3) << 4) | (orig[3 * i + 1] >> 4)) & 0x3F];
            result[4 * i + 2] = base64Char[(orig[3 * i + 1] << 2) & 0x3F];
        }
        else
        {
            result[4 * i + 1] = base64Char[((orig[3 * i] & 0x3) << 4) & 0x3F];
            result[4 * i + 2] = '=';
        }
        result[4 * i + 3] = '=';
    }

    result[numResultBytes] = '\0';
    return result;
}

int SmtpEmail::SMTPComunicate(const EmailInfo &info)
{

    if (Connect() != 0)
    {
        return -1;
    }
    char * buffer = new char[1000];
    memset(buffer, 0, 1000);

    Read(buffer, 999);
    if (strncmp(buffer, "220", 3) != 0) // not equal to 220
    {
        m_lastErrorMsg = buffer;
        return 220;
    }

    //向服务器发送ehlo
    std::string command = "ehlo EmailService\r\n";
    Write(command.c_str(), command.length());

    memset(buffer, 0, 1000);
    Read(buffer, 999);
    if (strncmp(buffer, "250", 3) != 0) // ehlo failed
    {
        m_lastErrorMsg = buffer;
        return 250;
    }

    //进行登录验证
    command = "AUTH PLAIN ";
    std::string auth = '\0' + info.senderEmail + '\0' + info.password;
    command += base64Encode(auth.data(), auth.size());
    command += "\r\n";
    Write(command.c_str(), command.length());

    memset(buffer, 0, 1000);
    Read(buffer, 999);
    if (strncmp(buffer, "235", 3) != 0) // login failed
    {
        m_lastErrorMsg = buffer;
        return 250;
    }

    //设置邮件发送者的邮箱地址
    command = "mail FROM:<" + info.senderEmail + ">\r\n";
    Write( command.c_str(), command.length());

    memset(buffer, 0, 1000);
    Read(buffer, 999);
    if (strncmp(buffer, "250", 3) != 0) // not ok
    {
        m_lastErrorMsg = buffer;
        return 250;
    }

    //设置邮件接收者的邮箱地址
    command = "RCPT TO:<" + info.recipientEmail + ">\r\n";
    Write( command.c_str(), command.length());

    memset(buffer, 0, 1000);
    Read( buffer, 999);
    if (strncmp(buffer, "250", 3) != 0) // not ok
    {
        m_lastErrorMsg = buffer;
        return 250;
    }



    //准备发送邮件
    command = "data\r\n";
    Write( command.c_str(), command.length());

    memset(buffer, 0, 1000);
    Read( buffer, 999);
    if (strncmp(buffer, "354", 3) != 0) // not ready to receive message
    {
        m_lastErrorMsg = buffer;
        return 354;
    }

    command = std::move(GetEmailBody(info));
    Write( command.c_str(), command.length());

    memset(buffer, 0, 1000);
    Read(buffer, 999);
    if (strncmp(buffer, "250", 3) != 0) // not ok
    {
        m_lastErrorMsg = buffer;
        return 250;
    }

    //结束发送过程
    delete buffer;
    Write( "quit\r\n", 6);

    DisConnect();
    return 0;
}

std::string SmtpEmail::GetEmailBody(const EmailInfo &info)
{
    //设定邮件的发送者名称、接收者名称、邮件主题,邮件内容。
    std::ostringstream message;
    message << "From: =?" << info.charset << "?b?" << base64Encode(info.sender.c_str(), info.sender.length()) << "?= <" << info.senderEmail << ">\r\n";

    std::vector<std::string> vecToList;
    for (auto item : info.recvList)
    {
        std::string to = "=?" + info.charset + "?b?" + base64Encode(item.second.c_str(), item.second.length()) + "?= <" + item.first + ">";
        vecToList.push_back(to);
    }

    message << "To: " << join(vecToList, ",") << "\r\n";
    message << "Subject: =?" << info.charset << "?b?" << base64Encode(info.subject.c_str(), info.subject.length()) << "?=\r\n";
    message << "MIME-Version: 1.0\r\n";

    if (info.ccEmail.size() > 0)
    {
        std::vector<std::string> vecCcList;
        for (auto item : info.ccEmail)
        {
            std::string cc = "=?" + info.charset + "?b?" + base64Encode(item.first.c_str(), item.first.length()) + "?= <" + item.second + ">";
            vecCcList.push_back(cc);
        }
        message << "Cc:" << join(vecCcList, ",") << "\r\n";
    }

    message << "Content-Type:multipart/mixed; boundary=\"Separator_ztq_000\"\r\n\r\n";
    message << "--Separator_ztq_000\r\n";
    message << "Content-Type: multipart/alternative; boundary=\"Separator_ztq_111\"\r\n\r\n";
    message << "--Separator_ztq_111\r\n";
    message << "Content-Type: " << "text/plain" << "; charset=\"" << info.charset << "\"\r\n";
    message << "Content-Transfer-Encoding: base64\r\n";
    message << "\r\n";                  //此处要加,不然邮件正文无内容
    message << base64Encode(info.message.c_str(), info.message.length());
    message << "\r\n\r\n";
    message << "--Separator_ztq_111--\r\n";
    //---------------------文件部分处理--------------------------------------

    for (auto item : info.attachment)
    {
        std::string filename = fileBasename(item);
        std::string strContext = getFileContents(item.c_str());
        if(strContext.empty())
        {
            std::cerr << "请检查传入的文件路径是否正确,此路径文件添加到附件失败,不发送此文件:" << std::endl;
            std::cerr << item << std::endl;
        }
        else
        {
            std::string fileContext = base64Encode(strContext.c_str(), strContext.length());
            std::string extension = GetFileExtension(filename);
            std::string mimetype = GetMimeTypeFromFileName((char*)extension.c_str());
            message << "--Separator_ztq_000\r\n";
            message << "Content-Type: " << mimetype << "; name=\"" << filename << "\"\r\n";
            message << "Content-Transfer-Encoding: base64\r\n";
            message << "Content-Disposition: attachment; filename=\"" << filename << "\"\r\n\r\n";
            message << fileContext + "\r\n\r\n";        //把读取到的文件内容以二进制形式发送
        }
    }
    //-----------------------------------------------------------
    message << "\r\n.\r\n";
    return message.str();
}

SmtpEmail::SmtpEmail(const std::string& emailHost, const std::string& port) :m_host(emailHost), m_port(port)
{

}

SmtpEmail::~SmtpEmail()
{

}

int SmtpEmail::Read(void* buf, int num)
{
    return recv(m_socketfd, (char*)buf, num, 0);
}
int SmtpEmail::Write(const void* buf, int num)
{
    return send(m_socketfd, (char*)buf, num, 0);
}

int SmtpEmail::Connect()
{
#ifdef WIN32
    //start socket connection
    WSADATA wsadata;
    WSAStartup(MAKEWORD(2, 2), &wsadata);
#endif

    m_socketfd = socket(AF_INET, SOCK_STREAM, 0);
    if (m_socketfd == INVALID_SOCKET)
    {

        m_lastErrorMsg = "Error on creating socket fd.";
        return -1;
    }

    addrinfo inAddrInfo = { 0 };
    inAddrInfo.ai_family = AF_INET;
    inAddrInfo.ai_socktype = SOCK_STREAM;

    printf("host:%s port:%s \n",m_host.c_str(), m_port.c_str());
    if (getaddrinfo(m_host.c_str(), m_port.c_str(), &inAddrInfo, &m_addrinfo) != 0) // error occurs
    {

        m_lastErrorMsg = "Error on calling getadrrinfo().";
        return -2;
    }


    if (connect(m_socketfd, m_addrinfo->ai_addr, m_addrinfo->ai_addrlen))
    {

        m_lastErrorMsg = "Error on calling connect().";
        return -3;
    }
    return 0;
}

int SmtpEmail::DisConnect()
{
    freeaddrinfo(m_addrinfo);
#ifdef WIN32
    closesocket(m_socketfd);
#else
    close(m_socketfd);
#endif
    return 0;
}

/*********************************************************************************/


std::string SimpleSmtpEmail::GetEmailBody(const EmailInfo &info)
{
    //设定邮件的发送者名称、接收者名称、邮件主题,邮件内容。
    std::ostringstream message;
    message << "From: =?" << info.charset << "?b?" << base64Encode(info.sender.c_str(), info.sender.length()) << "?= <" << info.senderEmail << ">\r\n";

    std::vector<std::string> vecToList;
    for (auto item : info.recvList)
    {
        std::string to = "=?" + info.charset + "?b?" + base64Encode(item.second.c_str(), item.second.length()) + "?= <" + item.first + ">";
        vecToList.push_back(to);
    }

    message << "To: " << join(vecToList, ",") << "\r\n";
    message << "Subject: =?" << info.charset << "?b?" << base64Encode(info.subject.c_str(), info.subject.length()) << "?=\r\n";
    message << "MIME-Version: 1.0\r\n";

    if (info.ccEmail.size() > 0)
    {
        std::vector<std::string> vecCcList;
        for (auto item : info.ccEmail)
        {
            std::string cc = "=?" + info.charset + "?b?" + base64Encode(item.first.c_str(), item.first.length()) + "?= <" + item.second + ">";
            vecCcList.push_back(cc);
        }
        message << "Cc:" << join(vecCcList, ",") << "\r\n";
    }

    message << "Content-Type:multipart/mixed; boundary=\"Separator_ztq_000\"\r\n\r\n";
    message << "--Separator_ztq_000\r\n";
    message << "Content-Type: multipart/alternative; boundary=\"Separator_ztq_111\"\r\n\r\n";
    message << "--Separator_ztq_111\r\n";
    message << "Content-Type: " << "text/plain" << "; charset=\"" << info.charset << "\"\r\n";
    message << "Content-Transfer-Encoding: base64\r\n";
    message << "\r\n";                  //此处要加,不然邮件正文无内容
    message << base64Encode(info.message.c_str(), info.message.length());
    message << "\r\n\r\n";
    message << "--Separator_ztq_111--\r\n";
    //---------------------文件部分处理--------------------------------------

    for (auto item : info.attachment)
    {
        std::string filename = fileBasename(item);
        std::string strContext = getFileContents(item.c_str());
        if(strContext.empty())
        {
            std::cerr << "请检查传入的文件路径是否正确,此路径文件添加到附件失败,不发送此文件:" << std::endl;
            std::cerr << item << std::endl;
        }
        else
        {
            std::string fileContext = base64Encode(strContext.c_str(), strContext.length());
            std::string extension = GetFileExtension(filename);
            std::string mimetype = GetMimeTypeFromFileName((char*)extension.c_str());
            message << "--Separator_ztq_000\r\n";
            message << "Content-Type: " << mimetype << "; name=\"" << filename << "\"\r\n";
            message << "Content-Transfer-Encoding: base64\r\n";
            message << "Content-Disposition: attachment; filename=\"" << filename << "\"\r\n\r\n";
            message << fileContext + "\r\n\r\n";        //把读取到的文件内容以二进制形式发送
        }
    }
    //-----------------------------------------------------------
    message << "\r\n.\r\n";
    return message.str();
}

/***************************************************************************************************/

SslSmtpEmail::~SslSmtpEmail()
{

}

int SslSmtpEmail::Connect()
{
    if (SmtpEmail::Connect() == 0)
    {
        SSL_library_init();
        OpenSSL_add_all_algorithms();
        SSL_load_error_strings();
        m_ctx = SSL_CTX_new(SSLv23_client_method());

        m_ssl = SSL_new(m_ctx);
        SSL_set_fd(m_ssl, m_socketfd);
        SSL_connect(m_ssl);
    }
    return 0;
}

int SslSmtpEmail::DisConnect()
{
    SSL_shutdown(m_ssl);
    SSL_free(m_ssl);
    SSL_CTX_free(m_ctx);

    SmtpEmail::DisConnect();
    return 0;
}



int SmtpEmail::SendEmail(const std::string& from, const std::string& passs, const std::string& to, const std::string& subject, const std::string& strMessage)
{

    EmailInfo info;
    info.charset = "UTF-8";
    info.sender = from;
    info.password = passs;
    info.senderEmail = from;
    info.recipientEmail = to;

    info.recvList[to] = "";

    info.subject = subject;
    info.message = strMessage;

    return SMTPComunicate(info);
}



int SmtpEmail::SendEmail(const std::string& from, const std::string& passs, const std::vector<std::string>& vecTo,
                         const std::string& subject, const std::string& strMessage, const std::vector<std::string>& attachment, const std::vector<std::string>& ccList)
{
    std::vector<std::string> recvList;
    recvList.insert(recvList.end(), vecTo.begin(), vecTo.end());
    recvList.insert(recvList.end(), ccList.begin(), ccList.end());

    for (auto& item : recvList)
    {
        EmailInfo info;
        info.charset = "UTF-8";
        info.sender = from;
        info.password = passs;
        info.senderEmail = from;;
        info.recipientEmail = item;

        for (auto item : vecTo)
        {
            info.recvList[item] = "";
        }

        info.subject = subject;
        info.message = strMessage;

        for (auto& item : ccList)
        {
            info.ccEmail[item] = item;
        }

        info.attachment = attachment;
        if (SMTPComunicate(info) != 0)
        {
            return -1;
        }
    }
    return 0;
}



int SslSmtpEmail::Read(void * buf, int num)
{

    int ret = SSL_read(m_ssl, buf, num);

    return ret;
}

int SslSmtpEmail::Write(const void * buf, int num)
{
    return SSL_write(m_ssl, buf, num);
}


std::string SimpleSslSmtpEmail::GetEmailBody(const EmailInfo &info)
{
    //设定邮件的发送者名称、接收者名称、邮件主题,邮件内容。
    std::ostringstream message;
    message << "From: =?" << info.charset << "?b?" << base64Encode(info.sender.c_str(), info.sender.length()) << "?= <" << info.senderEmail << ">\r\n";

    std::vector<std::string> vecToList;
    for (auto item : info.recvList)
    {
        std::string to = "=?" + info.charset + "?b?" + base64Encode(item.second.c_str(), item.second.length()) + "?= <" + item.first + ">";
        vecToList.push_back(to);
    }

    message << "To: " << join(vecToList, ",") << "\r\n";
    message << "Subject: =?" << info.charset << "?b?" << base64Encode(info.subject.c_str(), info.subject.length()) << "?=\r\n";
    message << "MIME-Version: 1.0\r\n";

    if (info.ccEmail.size() > 0)
    {
        std::vector<std::string> vecCcList;
        for (auto item : info.ccEmail)
        {
            std::string cc = "=?" + info.charset + "?b?" + base64Encode(item.first.c_str(), item.first.length()) + "?= <" + item.second + ">";
            vecCcList.push_back(cc);
        }
        message << "Cc:" << join(vecCcList, ",") << "\r\n";
    }
    message << "Content-Type:multipart/mixed; boundary=\"Separator_ztq_000\"\r\n\r\n";
    message << "--Separator_ztq_000\r\n";
    message << "Content-Type: multipart/alternative; boundary=\"Separator_ztq_111\"\r\n\r\n";
    message << "--Separator_ztq_111\r\n";
    message << "Content-Type: " << "text/plain" << "; charset=\"" << info.charset << "\"\r\n";
    message << "Content-Transfer-Encoding: base64\r\n";
    message << "\r\n";                  //此处要加,不然邮件正文无内容
    message << base64Encode(info.message.c_str(), info.message.length());
    message << "\r\n\r\n";
    message << "--Separator_ztq_111--\r\n";
    //---------------------文件部分处理--------------------------------------

    for (auto item : info.attachment)
    {
        std::string filename = fileBasename(item);
        std::string strContext = getFileContents(item.c_str());
        if(strContext.empty())
        {
            std::cerr << "请检查传入的文件路径是否正确,此路径文件添加到附件失败,不发送此文件:" << std::endl;
            std::cerr << item << std::endl;
        }
        else
        {
            std::string fileContext = base64Encode(strContext.c_str(), strContext.length());
            std::string extension = GetFileExtension(filename);
            std::string mimetype = GetMimeTypeFromFileName((char*)extension.c_str());
            message << "--Separator_ztq_000\r\n";
            message << "Content-Type: " << mimetype << "; name=\"" << filename << "\"\r\n";
            message << "Content-Transfer-Encoding: base64\r\n";
            message << "Content-Disposition: attachment; filename=\"" << filename << "\"\r\n\r\n";
            message << fileContext + "\r\n\r\n";        //把读取到的文件内容以二进制形式发送
        }
    }
    //-----------------------------------------------------------
    message << "\r\n.\r\n";
    return message.str();
}

测试代码 main.cpp

SendEmail函数重载,支持基本的简单发送文本邮件,和支持附件、抄送、以及发给多人的发送方式,亲测能够发送成功,默认发送的编码是utf-8格式

#include <iostream>
#include <stdio.h>
#include "mail.h"

int main()
{

    std::string from = "xxxx@163.com";
    std::string passs ="xxxxx";//这里替换成自己的授权码
    std::string to = "xxx@126.com";
    std::string subject = "hello";
    std::string strMessage = "test";


    std::vector<std::string> vecTo; //发送列表
    vecTo.push_back("xxx@126.com");

    std::vector<std::string> ccList;
    // ccList.push_back("xxx@xxx.com.cn");//抄送列表

    std::vector<std::string> attachment;
    attachment.push_back("mail.h");
    attachment.push_back("/home/soft/Desktop/openwrt-sdk-imx6ul/1/mybuild.sh");


    SmtpBase *base;
    SimpleSmtpEmail m_mail("smtp.163.com","25");
    base = &m_mail;
    //base->SendEmail(from, passs, to, subject, strMessage);//普通的文本发送,明文发送

    SimpleSslSmtpEmail m_ssl_mail("smtp.163.com","465");
    base=&m_ssl_mail;
    //base->SendEmail(from, passs, to, subject, strMessage);
    base->SendEmail(from, passs,vecTo,subject,strMessage,attachment,ccList);//加密的发送,支持抄送、附件等

    return 0;
}


邮箱收件箱
查看邮件头
c++实现smtp发送邮件,支持ssl的465端口发送,支持附件、一次发送多人、抄送等
收到的邮件
c++实现smtp发送邮件,支持ssl的465端口发送,支持附件、一次发送多人、抄送等

参考链接:

C++基于Smtp协议发送邮件
SMTP基本原理与C++实现向多人发送邮件

后记

如果您觉得有帮助的话,请点个赞吧!有问题请留言评论,欢迎指出意见,谢谢。文章来源地址https://www.toymoban.com/news/detail-474940.html

到了这里,关于c++实现smtp发送邮件,支持ssl的465端口发送,支持附件、一次发送多人、抄送等的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Go:实现SMTP邮件发送订阅功能(包含163邮箱、163企业邮箱、谷歌gmail邮箱)

    需求很简单,就是用户输入自己的邮箱后,使用官方邮箱给用户发送替邮件模版 邮件模版类似如下图发来的欢迎加入的模版 这里我们使用html格式存储模版,上图源码如下 选择好官方邮箱来开启smtp服务,这里我测试验证了163邮箱、163企业邮箱、谷歌gmail邮箱和腾讯企业邮箱(

    2024年02月08日
    浏览(66)
  • 使用SMTP协议发送邮件

    剧情介绍 今天心血来潮,学了一下Python3,里面有个章节是发送邮件,用示例里面的代码,运行后报错,然后记录一下问题是如何解决的,大家可以看一下,可以有效避坑。 SMTP简介 SMTP是一种提供可靠且有效的电子邮件传输的协议。SMTP是建立在FTP文件传输服务上的一种邮件服

    2024年02月05日
    浏览(66)
  • C# SMTP 邮件发送傻瓜操作

      /// summary  /// 发送邮件的方法  /// /summary  public OperateResultint SendMail(MailModel mails)  {      var resultData = new OperateResultint();      if (mails.to == null || !mails.to.Any())      {          resultData.Status = OperateStatus.Failure;          resultData.Description = \\\"收件人地址不能为空\\\";        

    2024年01月19日
    浏览(41)
  • Python SMTP发送邮件和线程

    SMTP(Simple Mail Transfer Protocol)即 简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则,由它来控制信件的中转方式 。 python的smtplib提供了一种很方便的途径发送电子邮件。它对smtp协议进行了简单的封装。 Python创建 SMTP 对象语法如下: 参数说明: host: SMTP 服

    2023年04月11日
    浏览(41)
  • 使用 office 365 SMTP 发送企业邮件

    最近公司的企业邮箱从 gmail 迁移到了 office 365。不得不说,微软 office 套件的功能在市场上还是无人可以取代的。公司自然需要用 office 365 向客户发送邮件,因此需要重新配置项目的 SMTP 服务器。 一开始直接将 gamil 的 SMTP 服务器地址换成 office 365 的地址即“smtp.office365.com”,

    2024年02月07日
    浏览(46)
  • python 学习笔记(5)——SMTP 使用QQ邮箱发送邮件

    目录 发送邮件 1、准备工作: 2、发送纯文本信息内容: 3、发送 HTML 格式的内容: 4、发送带附件的邮件: 5、群发(一个邮件,发给多个人):         以下都 以 QQ邮箱 为发送方举例;   1、准备工作:          使用 QQ邮箱发送邮件,需要到 “ 设置 ”=“ 账号 ”

    2024年02月09日
    浏览(50)
  • 无缓存定时发送带附件(表格)等邮件

    1.导入发送邮件的包 2.配置yml 3.添加定时任务 4.实现

    2024年02月11日
    浏览(41)
  • SMTP邮件发送图片-如何在github中存储图片并访问

    之前写了一篇文章 Go:实现SMTP邮件发送订阅功能(包含163邮箱、163企业邮箱、谷歌gmail邮箱),实现了通过邮箱服务来发送邮件,但都是文字内容,要是想实现邮件发送图片,就需要将图片放到公网可访问的服务器,这里用了骚操作。 实现邮件群发功能,来发送项目的周报及

    2024年02月06日
    浏览(45)
  • Springboot 使用JavaMailSender发送邮件 + Excel附件

    目录 1.生成Excel表格 1.依赖设置 2.代码: 2.邮件发送 1.邮件发送功能实现-带附件  2.踩过的坑 1.附件名中文乱码问题 3.参考文章: 需求描述:项目审批完毕后,需要发送邮件通知相关人员,并且要附带数据库表生成的Excel表格,这就要求不光是邮件发送功能,还要临时生成E

    2024年02月07日
    浏览(44)
  • 网工应用层:电子邮件Email、SMTP协议与使用Telnet发送电子邮件

    参考资料: https://www.bilibili.com/video/BV1c4411d7jb?p=72vd_source=e66dd25b0246f28e772d75f11c80f03c 湖科大的高军老师做的计算机网络课,去年选修的计网全靠高老师,生动,举例丰富,配套实验课,无废话纯干货,单推一波! 电子邮件(E-mail)是一种用电子手段提供信息交换的通信方式,是

    2024年02月14日
    浏览(91)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包