smtp_socket.hpp

浏览该文件的文档.

#ifndef NEFORCE_NEWORK_SMTP_SOCKET_HPP__
#define NEFORCE_NEWORK_SMTP_SOCKET_HPP__

 
#include "NeForce/core/container/map.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/network/dns/dns_client.hpp"
#include "NeForce/network/ssl/ssl_stream.hpp"
#include "NeForce/network/ip_socket.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct NEFORCE_API smtp_exception final : network_exception {
    explicit smtp_exception(const char* info = "SMTP Operation Failed.", const char* type = static_type,
                            const int code = 0) noexcept :
    network_exception(info, type, code) {}
 
    explicit smtp_exception(const exception& e) :
    network_exception(e) {}
 
    ~smtp_exception() override = default;
 
    static constexpr auto static_type = "smtp_exception";
};
 // Exceptions


struct NEFORCE_API smtp_message {
    string from;                       
    vector<string> to;                 
    vector<string> cc;                 
    vector<string> bcc;                
    string subject;                    
    string body;                       
    bool is_html = false;              
    map<string, string> extra_headers; 
};

class NEFORCE_API smtp_socket final : public ip_socket {
public:
    enum class auth_method {
        none,  
        plain, 
        login  
    };

    enum class tls_mode {
        none,     
        implicit, 
        starttls  
    };

    struct response {
        int code;       
        string message; 

        NEFORCE_NODISCARD bool is_success() const noexcept { return code >= 200 && code < 400; }
    };

    struct starttls_result {
        bool upgraded = false;      
        string cipher_name;         
        string tls_version;         
        bool peer_verified = false; 
    };
 
private:
    string server_domain_;   
    bool connected_ = false; 
 
    tls_mode tls_mode_ = tls_mode::none; 
    bool tls_active_ = false;            
 
    ssl_stream ssl_; 
 
    ssize_t raw_send(const char* data, size_t len);
    ssize_t raw_recv(char* buf, size_t len);
 
    bool read_line(string& out);
    response read_response();
    response send_command(const string& cmd);
    void expect_code(int expected, const string& cmd);
 
    vector<string> do_ehlo(const string& domain);
 
    void do_post_connect(const string& domain, tls_mode mode, const ssl_context* ctx, const string& sni_hostname);
 
    void do_tls_handshake(const ssl_context& ctx, const string& sni_hostname);
 
    void open_and_connect(const ip_address& addr);
 
public:
    smtp_socket() = default;

    explicit smtp_socket(native_handle_type fd) noexcept :
    ip_socket(fd) {}

    void connect(const ip_address& addr, const string& domain = "localhost", tls_mode mode = tls_mode::none,
                 const ssl_context* ctx = nullptr, const string& sni_hostname = "");

    void connect(const string& hostname, ports port, const string& domain = "localhost", tls_mode mode = tls_mode::none,
                 dns_client* dns = nullptr, const ssl_context* ctx = nullptr, const string& sni_hostname = "");

    starttls_result starttls(const ssl_context& ctx, const string& sni_hostname = "");

    void disconnect();

    void authenticate(const string& username, const string& password, auth_method method = auth_method::plain);

    void send(const smtp_message& msg);

    void noop();

    NEFORCE_NODISCARD bool is_connected() const noexcept { return connected_ && is_open(); }

    NEFORCE_NODISCARD bool is_tls_active() const noexcept { return tls_active_; }

    NEFORCE_NODISCARD bool verify_peer() const { return ssl_.verify_peer(); }

    NEFORCE_NODISCARD string cipher_name() const { return ssl_.get_cipher_name(); }

    NEFORCE_NODISCARD string tls_version() const { return ssl_.get_version(); }
};
 // Network
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NEWORK_SMTP_SOCKET_HPP__