例 843. SFXSMTPSender クラスの実装

/***************************************************************************************
****************************************************************************************
***
***     File            : SFXSMTPSender.f.hpp
***
****************************************************************************************
****************************************************************************************/

#ifndef __SOPHIAFRAMEWORK_SFXSMTPSENDER_FHPP
#define __SOPHIAFRAMEWORK_SFXSMTPSENDER_FHPP

#include <SFXGeneral/SFXEnvironment.h.hpp>

SFMTYPEDEFCLASS(SFXSMTPSENDER)

#endif // __SOPHIAFRAMEWORK_SFXSMTPSENDER_FHPP //


/***************************************************************************************
****************************************************************************************
***
***     File            : SFXSMTPSender.h.hpp
***
****************************************************************************************
****************************************************************************************/

#ifndef __SOPHIAFRAMEWORK_SFXSMTPSENDER_HHPP
#define __SOPHIAFRAMEWORK_SFXSMTPSENDER_HHPP

#include <SFXGeneral/SFXEnvironment.h.hpp>
#include <SFXProtocol/SFXMail/SFXSMTPSender.f.hpp>
#include <SFXProtocol/SFXMail/SFXSMTP.h.hpp>
#include <SFXCollection/SFXArray.h.hpp>
#include <SFXProtocol/SFXMail/SFXMailMessage.f.hpp>

class SFXSMTPSender {
    SFMSEALCOPY(SFXSMTPSender)
    public:
        enum ProgressEnum {
            PROGRESS_NONE                       = 0,
            PROGRESS_CONNECT,
            PROGRESS_EHLO,
            PROGRESS_HELO,
            PROGRESS_AUTH,
            PROGRESS_AUTHRESP1,
            PROGRESS_AUTHRESP2,
            PROGRESS_MAIL,
            PROGRESS_RCPT,
            PROGRESS_DATA,
            PROGRESS_DATATEXT,
            PROGRESS_QUIT,
            PROGRESS_ERRORQUIT,
            PROGRESS_DONE
        };
        enum AuthEnum {
            AUTH_NONE                           = 0,
            AUTH_PLAIN,
            AUTH_LOGIN,
            AUTH_CRAM_MD5,
            AUTH_DIGEST_MD5
        };
    private:
        enum StateEnum {
            STATE_STANDBY                       = 0,
            STATE_SENDING
        };

    public:
        typedef Void                            (*CallbackSPP)                  (SFCError error, VoidPtr reference);

    private:
                StateEnum                       _state;
                ProgressEnum                    _progress;
                ProgressEnum                    _previous;
                CallbackSPP                     _spp;
                VoidPtr                         _reference;
                AuthEnum                        _auth;
                SFXAnsiString                   _user;
                SFXAnsiString                   _password;
                SFXSocketAddress                _server;
                SFXAnsiString                   _client;
                SFXAnsiString                   _from;
                SFXArray<SFXAnsiStringPtr>      _toList;
                SFXAnsiString                   _message;
                SFXSMTP                         _smtp;
                SInt16                          _index;
                Bool                            _quit;
                Bool                            _isSSL;
                UInt32                          _sslTrustMode;

    public:
        explicit                                SFXSMTPSender                   (Void);
                                                ~SFXSMTPSender                  (Void);
                SFXSMTPRef                      GetSFXSMTP                      (Void);
                ProgressEnum                    GetProgress                     (Void) const;
                Void                            SetSSLMode                      (Bool isSSL);
                Bool                            GetSSLMode                      (Void) const;
                Void                            SetTrustMode                    (UInt32 sslTrustMode);
                UInt32                          GetTrustMode                    (Void) const;
                Void                            Cancel                          (Void);
                SFCError                        SetHostName                     (SFXAnsiStringConstRef host);
                SFCError                        SetServer                       (SFXSocketAddressConstRef server);
                SFCError                        SetAuthorization                (SFXSMTPSender::AuthEnum auth, SFXAnsiStringConstRef user, SFXAnsiStringConstRef password);
                SFCError                        SetFrom                         (SFXAnsiStringConstRef from);
                Void                            ClearTo                         (Void);
                SFCError                        AddTo                           (SFXAnsiStringConstRef to);
                SFCError                        SendMessage                     (SFXMailMessagePtr message, CallbackSPP spp, VoidPtr reference);
                SFCError                        SendText                        (SFXAnsiStringConstRef text, CallbackSPP spp, VoidPtr reference);
                Bool                            IsQuit                          (Void);
    private:
                SFCError                        ProceedConnect                  (UInt16 code);
                SFCError                        ProceedEhlo                     (UInt16 code);
                SFCError                        ProceedHelo                     (UInt16 code);
                SFCError                        ProceedAuth                     (UInt16 code);
                SFCError                        ProceedAuthresp1                (UInt16 code);
                SFCError                        ProceedAuthresp2                (UInt16 code);
                SFCError                        ProceedMail                     (UInt16 code);
                SFCError                        ProceedRcpt                     (UInt16 code);
                SFCError                        ProceedData                     (UInt16 code);
                SFCError                        ProceedDataText                 (UInt16 code);
                Void                            ProceedError                    (Void);
                Void                            FinishSend                      (SFCError err);
                SFCError                        SetBrackets                     (SFXAnsiStringConstRef string, SFXAnsiStringPtr result);
                XALLBACK_DECLARE_SFXSMTP(OnSMTP)
};

#define     XALLBACK_DECLARE_SFXSMTPSENDER(FUNCTION)                            XALLBACK_DECLARE_SFXSMTP(FUNCTION)

#include <SFXProtocol/SFXMail/SFXSMTPSender.i.hpp>


#endif // __SOPHIAFRAMEWORK_SFXSMTPSENDER_HHPP //


/***************************************************************************************
****************************************************************************************
***
***     File            : SFXSMTPSender.i.hpp
***
****************************************************************************************
****************************************************************************************/

#ifndef __SOPHIAFRAMEWORK_SFXSMTPSENDER_IHPP
#define __SOPHIAFRAMEWORK_SFXSMTPSENDER_IHPP

#include <SFXGeneral/SFXEnvironment.h.hpp>

/*public */inline SFXSMTPRef SFXSMTPSender::GetSFXSMTP(Void)
{
    return _smtp;
}// SFXSMTPSender::GetSFXSMTP //

/*public */inline SFXSMTPSender::ProgressEnum SFXSMTPSender::GetProgress(Void) const
{
    return _progress;
}// SFXSMTPSender::GetProgress //

/*public */inline Void SFXSMTPSender::SetSSLMode(Bool isSSL)
{
    _isSSL = isSSL;
    return;
}// SFXSMTPSender::SetSSLMode //

/*public */inline Bool SFXSMTPSender::GetSSLMode(Void) const
{
    return _isSSL;
}// SFXSMTPSender::GetSSLMode //

/*public */inline Void SFXSMTPSender::SetTrustMode(UInt32 sslTrustMode)
{
    _sslTrustMode = sslTrustMode;
    return;
}// SFXSMTPSender::SetTrustMode //

/*public */inline UInt32 SFXSMTPSender::GetTrustMode(Void) const
{
    return _sslTrustMode;
}// SFXSMTPSender::GetTrustMode //

/*public */inline SFCError SFXSMTPSender::SetHostName(SFXAnsiStringConstRef host)
{
    return _client.Set(host);
}// SFXSMTPSender::SetHostName //

/*public */inline SFCError SFXSMTPSender::SetServer(SFXSocketAddressConstRef server)
{
    return _server.Set(server);
}// SFXSMTPSender::SetServer //

/*public */inline SFCError SFXSMTPSender::SetFrom(SFXAnsiStringConstRef from)
{
    return _from.Set(from);
}// SFXSMTPSender::SetFrom //

/*public */inline Bool SFXSMTPSender::IsQuit(Void)
{
    return _quit;
}// SFXSMTPSender::IsQuit //

#define     XALLBACK_IMPLEMENT_SFXSMTPSENDER(TYPE, FUNCTION, ERROR)             XALLBACK_IMPLEMENT_SFXSMTP(TYPE, FUNCTION, ERROR)

#endif // __SOPHIAFRAMEWORK_SFXSMTPSENDER_IHPP //


/***************************************************************************************
****************************************************************************************
***
***     File            : SFXSMTPSender.i.cpp
***
****************************************************************************************
****************************************************************************************/

#include <SFXProtocol/SFXMail/SFXSMTPSender.h.hpp>
#include <SFXProtocol/SFXMail/SFXMailMessage.h.hpp>
#include <SFXProtocol/SFXMail/SFXMailUtility.h.hpp>

/*public */SFXSMTPSender::SFXSMTPSender(Void) : _state(STATE_STANDBY), _progress(PROGRESS_NONE), _auth(AUTH_NONE), _quit(false), _isSSL(false), _sslTrustMode(SSL_TRUST_MODE_FAIL)
{
}// SFXSMTPSender::SFXSMTPSender //

/*public */SFXSMTPSender::~SFXSMTPSender(Void)
{
    Cancel();
}// SFXSMTPSender::~SFXSMTPSender //

/*public */Void SFXSMTPSender::Cancel(Void)
{
    _state = STATE_STANDBY;
    _progress = PROGRESS_NONE;
    _spp = null;
    _reference = null;
    _server.Set(0, 0);
    _from.Clear();
    ClearTo();
    _message.Clear();
    _smtp.Close();
}// SFXSMTPSender::Cancel //

/*public */SFCError SFXSMTPSender::SetAuthorization(SFXSMTPSender::AuthEnum auth, SFXAnsiStringConstRef user, SFXAnsiStringConstRef password)
{
    SFCError error;

    if ((error = _user.Set(user)) == SFERR_NO_ERROR) {
        if ((error = _password.Set(password)) == SFERR_NO_ERROR) {
            _auth = auth;
        }
    }
    return error;
}// SFXSMTPSender::SetAuthorization //

/*public */Void SFXSMTPSender::ClearTo(Void)
{
    SFXArray<SFXAnsiStringPtr>::Iterator itor;
    SFXAnsiStringPtr string;

    itor = _toList.GetFirstIterator();
    while (itor.HasNext()) {
        string = itor.GetNext();
        ::delete string;
    }
    _toList.Clear();
}// SFXSMTPSender::ClearTo //

/*public */SFCError SFXSMTPSender::AddTo(SFXAnsiStringConstRef to)
{
    SFCError error;
    SFXAnsiStringPtr string;

    if ((string = ::new SFXAnsiString(to)) != null) {
        error = _toList.InsertLast(string);
    }
    else {
        error = SFERR_NO_MEMORY;
    }
    return error;
}// SFXSMTPSender::AddTo //

/*public */SFCError SFXSMTPSender::SendMessage(SFXMailMessagePtr message, CallbackSPP spp, VoidPtr reference)
{
    SFCError error(SFERR_NO_ERROR);
    SFBNetMgrSmp net;
    SFXAnsiString temp;
    SInt32 r0, r1;
    SFXProperty property;
    SFXAnsiStringPtr mail;

    if (!_server.Get().IsEmpty()) {
        if (error == SFERR_NO_ERROR) {
            if (_from.IsEmpty()) {
                _from = message->GetFromField();
            }
            if (_toList.IsEmpty()) {
                if ((error = SFXMailUtility::ParseMailboxList(message->GetToField(), &property)) == SFERR_NO_ERROR) {
                    if ((error = SFXMailUtility::ParseMailboxList(message->GetCcField(), &property)) == SFERR_NO_ERROR) {
                        if ((error = SFXMailUtility::ParseMailboxList(message->GetBccField(), &property)) == SFERR_NO_ERROR) {
                            r1 = property.GetSize();
                            for (r0 = 0; r0 < r1; ++r0) {
                                if ((mail = ::new SFXAnsiString) != null) {
                                    if ((error = mail->Set(property.GetValue(r0))) == SFERR_NO_ERROR) {
                                        if ((error = _toList.InsertLast(mail)) != SFERR_NO_ERROR) {
                                            break;
                                        }
                                    }
                                    else {
                                        break;
                                    }
                                }
                                else {
                                    error = SFERR_NO_MEMORY;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        if (error == SFERR_NO_ERROR) {
            if (message->GetBccField().IsEmpty()) {
                error = _message.Set(message->Write());
            }
            else {
                if ((error = temp.Set(message->Write())) == SFERR_NO_ERROR) {
                    if ((r0 = temp.FirstIndexOf("BCC:", SINT32_MINIMUM, false)) > -1) {
                        r1 = temp.FirstIndexOf("\r\n", r0);
                        if ((error = _message.Set(temp.Substring(0, r0))) == SFERR_NO_ERROR) {
                            error = _message.Add(temp.Substring(r1 + 2, temp.GetLength()));
                        }
                    }
                    else {
                        error = SFERR_FAILED;
                    }
                }
            }
        }
        if (error == SFERR_NO_ERROR) {
            if (!_from.IsEmpty() && !_toList.IsEmpty()) {
                _smtp.Close();
                if ((error = _smtp.Open()) == SFERR_NO_ERROR) {
                    _smtp.SetSSLMode(_isSSL);
                    if ((error = _smtp.SetTrustMode(_sslTrustMode)) == SFERR_NO_ERROR) {
                        if ((error = _smtp.Connect(_server, XALLBACK_INTERNAL(OnSMTP))) == SFERR_NO_ERROR) {
                            _state = STATE_SENDING;
                            _progress = PROGRESS_CONNECT;
                            _spp = spp;
                            _reference = reference;
                            _quit = false;
                        }
                    }
                    if (error != SFERR_NO_ERROR) {
                        _smtp.Close();
                    }
                }
            }
            else {
                error = SFERR_INVALID_PARAM;
            }
        }
    }
    else {
        error = SFERR_FAILED;
    }
    return error;
}// SFXSMTPSender::SendMessage //

/*public */SFCError SFXSMTPSender::SendText(SFXAnsiStringConstRef text, CallbackSPP spp, VoidPtr reference)
{
    SFCError error(SFERR_NO_ERROR);
    _message.Set(text); // temp
    if (!_client.IsEmpty() && !_from.IsEmpty() && !_toList.IsEmpty()) {
        _smtp.Close();
        if ((error = _smtp.Open()) == SFERR_NO_ERROR) {
            _smtp.SetSSLMode(_isSSL);
            if ((error = _smtp.SetTrustMode(_sslTrustMode)) == SFERR_NO_ERROR) {
                if ((error = _smtp.Connect(_server, XALLBACK_INTERNAL(OnSMTP))) == SFERR_NO_ERROR) {
                    _state = STATE_SENDING;
                    _progress = PROGRESS_CONNECT;
                    _spp = spp;
                    _reference = reference;
                    _quit = false;
                }
            }
            if (error != SFERR_NO_ERROR) {
                _smtp.Close();
            }
        }
    }
    else {
        error = SFERR_INVALID_PARAM;
    }
    return error;
}// SFXSMTPSender::SendText //

/*private */XALLBACK_IMPLEMENT_SFXSMTP(SFXSMTPSender, OnSMTP, error)
{
    SIntN code;

    if (error == SFERR_NO_ERROR) {
        code = _smtp.GetResponseCode();
        switch (_progress) {
            case PROGRESS_CONNECT:
                error = ProceedConnect(code);
                break;
            case PROGRESS_EHLO:
                error = ProceedEhlo(code);
                break;
            case PROGRESS_HELO:
                error = ProceedHelo(code);
                break;
            case PROGRESS_AUTH:
                error = ProceedAuth(code);
                break;
            case PROGRESS_AUTHRESP1:
                error = ProceedAuthresp1(code);
                break;
            case PROGRESS_AUTHRESP2:
                error = ProceedAuthresp1(code);
                break;
            case PROGRESS_MAIL:
                error = ProceedMail(code);
                break;
            case PROGRESS_RCPT:
                error = ProceedRcpt(code);
                break;
            case PROGRESS_DATA:
                error = ProceedData(code);
                break;
            case PROGRESS_DATATEXT:
                error = ProceedDataText(code);
                break;
            case PROGRESS_ERRORQUIT:
                _progress = PROGRESS_DONE;
                FinishSend(_previous);
                break;
            case PROGRESS_QUIT:
                _progress = PROGRESS_DONE;
                FinishSend(SFERR_NO_ERROR);
                break;
            case PROGRESS_DONE:
            case PROGRESS_NONE:
            default:
                FinishSend(PROGRESS_NONE);
                break;
        }
    }
    if (error != SFERR_NO_ERROR) {
        FinishSend(_progress);
    }
}// XALLBACK_IMPLEMENT_SFXSMTP(SFXSMTPSender, OnSMTP, error) //

/*private */SFCError SFXSMTPSender::ProceedConnect(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);
    SFXInetAddress address;

    if (code == 220) {
        _progress = PROGRESS_EHLO;
        if (_client.IsEmpty()) {
            address = SFXInetAddress::LocalInetAddress();
            if (!address.Get().IsEmpty()) {
                error = _client.Set(address.Get());
            }
            else {
                error = SFERR_FAILED;
            }
        }
        error = _smtp.SendEhloCommand(_client);
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedConnect //

/*private */SFCError SFXSMTPSender::ProceedEhlo(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);
    SFXSMTP::AuthEnum auth(SFXSMTP::AUTH_NONE);
    SFXAnsiString temp;

    if (_auth == AUTH_NONE) {
        if (code == 250) {
            _progress = PROGRESS_MAIL;
            if ((error = SetBrackets(_from, &temp)) == SFERR_NO_ERROR) {
                error = _smtp.SendMailCommand(temp);
            }
        }
        else {
            _progress = PROGRESS_HELO;
            error = _smtp.SendHeloCommand(_client);
        }
    }
    else {
        if (code == 250) {
            _progress = PROGRESS_AUTH;
            switch (_auth) {
                case AUTH_NONE:
                    auth = SFXSMTP::AUTH_NONE;
                    break;
                case AUTH_PLAIN:
                    auth = SFXSMTP::AUTH_PLAIN;
                    break;
                case AUTH_LOGIN:
                    auth = SFXSMTP::AUTH_LOGIN;
                    break;
                case AUTH_CRAM_MD5:
                    auth = SFXSMTP::AUTH_CRAM_MD5;
                    break;
                case AUTH_DIGEST_MD5:
                    auth = SFXSMTP::AUTH_DIGEST_MD5;
                    break;
                default:
                    break;
            }
            error = _smtp.SendAuthCommand(auth);
        }
        else {
            ProceedError();
        }
    }
    return error;
}// SFXSMTPSender::ProceedEhlo //

/*private */SFCError SFXSMTPSender::ProceedHelo(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);
    SFXAnsiString temp;

    if (code == 220) {
        _progress = PROGRESS_MAIL;
        if ((error = SetBrackets(_from, &temp)) == SFERR_NO_ERROR) {
            error = _smtp.SendMailCommand(temp);
        }
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedHelo //

/*private */SFCError SFXSMTPSender::ProceedAuth(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);

    if (code == 334) {
        _progress = PROGRESS_AUTHRESP1;
        switch (_auth) {
            case AUTH_PLAIN:
                error = _smtp.SendAuthResponse(_user, _password);
                break;
            case AUTH_LOGIN:
                error = _smtp.SendAuthResponse(_user);
                break;
            case AUTH_CRAM_MD5:
                error = _smtp.SendAuthResponse(_user, _password, _smtp.GetResponseText());
                break;
            case AUTH_NONE:
            case AUTH_DIGEST_MD5:
            default:
                // DIGEST_MD5 has not been supported yet.
                _previous = _progress;
                _progress = PROGRESS_ERRORQUIT;
                if ((error = _smtp.SendQuitCommand()) == SFERR_NO_ERROR) {
                    _quit = true;
                }
                break;
        }
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedAuth //

/*private */SFCError SFXSMTPSender::ProceedAuthresp1(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);
    SFXAnsiString temp;

    if (code == 334) {
        if (_auth == AUTH_LOGIN) {
            _progress = PROGRESS_AUTHRESP2;
            error = _smtp.SendAuthResponse(_password);
        }
    }
    else if (code == 235) {
        _progress = PROGRESS_MAIL;
        if ((error = SetBrackets(_from, &temp)) == SFERR_NO_ERROR) {
            error = _smtp.SendMailCommand(temp);
        }
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedAuthresp1 //

/*private */SFCError SFXSMTPSender::ProceedAuthresp2(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);
    SFXAnsiString temp;

    if (code == 235) {
        _progress = PROGRESS_MAIL;
        if ((error = SetBrackets(_from, &temp)) == SFERR_NO_ERROR) {
            error = _smtp.SendMailCommand(temp);
        }
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedAuthresp2 //

/*private */SFCError SFXSMTPSender::ProceedMail(UInt16 code)
{
    SFXAnsiString temp;
    SFCError error(SFERR_NO_ERROR);

    if (code == 250) {
        _progress = PROGRESS_RCPT;
        _index = 0;
        if ((error = SetBrackets(*_toList[0], &temp)) == SFERR_NO_ERROR) {
            error = _smtp.SendRcptCommand(temp);
        }
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedMail //

/*private */SFCError SFXSMTPSender::ProceedRcpt(UInt16 code)
{
    SFXAnsiString temp;
    SFCError error(SFERR_NO_ERROR);

    if (code == 250 || code == 251) {
        ++_index;
        if (_index < _toList.GetSize()) {
            if ((error = SetBrackets(*_toList[_index], &temp)) == SFERR_NO_ERROR) {
                error = _smtp.SendRcptCommand(temp);
            }
        }
        else {
            _progress = PROGRESS_DATA;
            error = _smtp.SendDataCommand();
        }
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedRcpt //

/*private */SFCError SFXSMTPSender::ProceedData(UInt16 code)
{
    SFCError error(SFERR_NO_ERROR);

    if (code == 354) {
        _progress = PROGRESS_DATATEXT;
        error = _smtp.SendDataText(_message);
    }
    else {
        ProceedError();
    }
    return error;
}// SFXSMTPSender::ProceedData //

/*private */SFCError SFXSMTPSender::ProceedDataText(UInt16 /*code*/)
{
    SFCError error(SFERR_NO_ERROR);

    _progress = PROGRESS_QUIT;
    if ((error = _smtp.SendQuitCommand()) == SFERR_NO_ERROR) {
        _quit = true;
    }
    return error;
}// SFXSMTPSender::ProceedDataText //

/*private */Void SFXSMTPSender::ProceedError(Void)
{
    _previous = _progress;
    _progress = PROGRESS_ERRORQUIT;
    if (_smtp.SendQuitCommand() == SFERR_NO_ERROR) {
        _quit = true;
    }
    return;
}// SFXSMTPSender::ProceedError //

/*private */Void SFXSMTPSender::FinishSend(SFCError error)
{
    _state = STATE_STANDBY;
    _smtp.Close();
    if (_spp != null) {
        _spp(error, _reference);
    }
    return;
}// SFXSMTPSender::FinishSend //

/*private */SFCError SFXSMTPSender::SetBrackets(SFXAnsiStringConstRef string, SFXAnsiStringPtr result)
{
    SFCError error(SFERR_NO_ERROR);

    if (string.StartsWith('<') && string.EndsWith('>')) {
        error = result->Set(string);
    }
    else {
        if ((error = result->Set('<')) == SFERR_NO_ERROR) {
            if ((error = result->Add(string)) == SFERR_NO_ERROR) {
                error = result->Add('>');
            }
        }
    }
    return error;
}// SFXSMTPSender::SetBrackets //