例 836. SFXPOP3Receiver クラスの実装

/***************************************************************************************
****************************************************************************************
***
***     File            : SFXPOP3Receiver.f.hpp
***
****************************************************************************************
****************************************************************************************/

#ifndef __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_FHPP
#define __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_FHPP

#include <SFXGeneral/SFXEnvironment.h.hpp>

SFMTYPEDEFCLASS(SFXPOP3Receiver)

#endif // __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_FHPP //


/***************************************************************************************
****************************************************************************************
***
***     File            : SFXPOP3Receiver.h.hpp
***
****************************************************************************************
****************************************************************************************/

#ifndef __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_HHPP
#define __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_HHPP

#include <SFXGeneral/SFXEnvironment.h.hpp>
#include <SFXProtocol/SFXMail/SFXPOP3Receiver.f.hpp>
#include <SFXProtocol/SFXMail/SFXPOP3.h.hpp>
#include <SFXCollection/SFXArray.h.hpp>

class SFXPOP3Receiver {
    SFMSEALCOPY(SFXPOP3Receiver)
    public:
        enum ProgressEnum {
            PROGRESS_NONE                       = 0,
            PROGRESS_CONNECT,
            PROGRESS_USER,
            PROGRESS_PASS,
            PROGRESS_LIST,
            PROGRESS_UIDL,
            PROGRESS_TOP,
            PROGRESS_RETR,
            PROGRESS_DELE,
            PROGRESS_QUIT,
            PROGRESS_DONE
        };
        enum AuthEnum {
            AUTH_NONE                           = 0,
            AUTH_APOP_AND_USERPASS,
            AUTH_ONLY_APOP,
            AUTH_ONLY_USERPASS
        };
    private:
        enum StateEnum {
            STATE_STANDBY                       = 0,
            STATE_RECEIVING
        };

    public:
        typedef Void                            (*CallbackSPP)                  (SFCError error, VoidPtr reference);
        SFMTYPEDEFSTRUCT(MailInfo)
        struct MailInfo {
            UInt32                              size;
            SFXAnsiString                       uidl;
            SFXAnsiString                       mail;
        };
        SFMTYPEDEFALIAS(SFXArray<SFXAnsiStringPtr>, UidlArray)
        SFMTYPEDEFALIAS(SFXArray<MailInfoPtr>, MailArray)

    private:
                StateEnum                       _state;
                ProgressEnum                    _progress;
                CallbackSPP                     _spp;
                VoidPtr                         _reference;
                SFXPOP3                         _pop3;
                SFXSocketAddress                _server;
                SFXAnsiString                   _user;
                SFXAnsiString                   _password;
                SInt32                          _line;
                UInt32                          _limit;
                UidlArray                       _singleUidlArray;
                UidlArrayPtr                    _targetUidlArray;
                Bool                            _invertTarget;
                Bool                            _isAutoDelete;
                SInt32                          _deleteCandNum;
                Bool                            _noUidl;
                AuthEnum                        _auth;
                Bool                            _apop;
                MailArray                       _receivedMailArray;
                SFXPOP3::NumberSizeRecPtr       _numSizeList;
                SInt32                          _numSizeCount;
                SFXPOP3::NumberUidlRecPtr       _numUidlList;
                SInt32                          _numUidlCount;
                SInt32                          _numSizeIndex;
                UInt32                          _index;
                MailInfo                        _nextMailInfo;
                Bool                            _isSSL;
                UInt32                          _sslTrustMode;

    public:
        explicit                                SFXPOP3Receiver                 (Void);
                                                ~SFXPOP3Receiver                (Void);
                SFXPOP3Ref                      GetSFXPOP3                      (Void);
                ProgressEnum                    GetProgress                     (Void) const;
                Void                            SetSSLMode                      (Bool isSSL);
                Bool                            GetSSLMode                      (Void) const;
                Void                            SetTrustMode                    (UInt32 sslTrustMode);
                UInt32                          GetTrustMode                    (Void) const;
                Void                            SetAutoDelete                   (Bool isAutoDelete);
                Bool                            GetAutoDelete                   (Void) const;
                Void                            Cancel                          (Void);
                Void                            Clear                           (Void);
                Void                            SetServer                       (SFXSocketAddressConstRef server);
                Void                            SetLimit                        (UInt32 limit);
                Void                            SetNumberOfLines                (SInt32 number);
                SFCError                        SetAccount                      (SFXAnsiStringConstRef user, SFXAnsiStringConstRef password, AuthEnum auth = AUTH_APOP_AND_USERPASS);
                SFCError                        Receive                         (CallbackSPP spp, VoidPtr reference);
                SFCError                        Receive                         (SFXAnsiStringConstRef targetUidl, CallbackSPP spp, VoidPtr reference);
                SFCError                        Receive                         (UidlArrayPtr targetUidlArray, Bool invertTarget, CallbackSPP spp, VoidPtr reference);
                SFCError                        Delete                          (CallbackSPP spp, VoidPtr reference);
                SFCError                        Delete                          (SFXAnsiStringConstRef uidl, CallbackSPP spp, VoidPtr reference);
                SFCError                        Delete                          (UidlArrayPtr targetUidlArray, Bool invertTarget, CallbackSPP spp, VoidPtr reference);
                MailArrayConstRef               GetReceivedMailArray            (Void) const;
    private:
                SFCError                        ProceedConnect                  (Void);
                SFCError                        ProceedUser                     (Void);
                SFCError                        ProceedPass                     (Void);
                SFCError                        ProceedList                     (Void);
                SFCError                        ProceedUidl                     (Bool receiving);
                SFCError                        ProceedReceivingRetr            (Void);
                SFCError                        SendAuthCommand                 (Void);
                SFCError                        ReceiveNextMail                 (BoolPtr next);
                SFCError                        DeleteNextMail                  (BoolPtr next);
                Void                            Finish                          (SFCError error);
                SFCError                        SetSingleUidl                   (SFXAnsiStringConstRef uidl);
                Void                            FreeNumSizeList                 (Void);
                Void                            FreeNumUidlList                 (Void);
                Void                            FreeSingleUidl                  (Void);
                Bool                            IsTargetUidl                    (SFXAnsiStringConstRef uidl);
                SInt32                          FindNextTarget                  (Void);
                XALLBACK_DECLARE_SFXPOP3(OnPOP3Receive)
                XALLBACK_DECLARE_SFXPOP3(OnPOP3Delete)
};

#define     XALLBACK_DECLARE_SFXPOP3RECEIVER(FUNCTION)                          XALLBACK_DECLARE_SFXPOP3(FUNCTION)

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

#endif // __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_HHPP //


/***************************************************************************************
****************************************************************************************
***
***     File            : SFXPOP3Receiver.i.hpp
***
****************************************************************************************
****************************************************************************************/

#ifndef __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_IHPP
#define __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_IHPP

#include <SFXGeneral/SFXEnvironment.h.hpp>

/*public */inline SFXPOP3Ref SFXPOP3Receiver::GetSFXPOP3(Void)
{
    return _pop3;
}// SFXPOP3Receiver::GetSFXPOP3 //

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

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

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

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

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

/*public */inline Void SFXPOP3Receiver::SetAutoDelete(Bool isAutoDelete)
{
    _isAutoDelete = isAutoDelete;
    return;
}// SFXPOP3Receiver::SetAutoDelete //

/*public */inline Bool SFXPOP3Receiver::GetAutoDelete(Void) const
{
    return _isAutoDelete;
}// SFXPOP3Receiver::GetAutoDelete //

/*public */inline Void SFXPOP3Receiver::SetServer(SFXSocketAddressConstRef server)
{
    _server.Set(server);
}// SFXPOP3Receiver::SetServer //

/*public */inline Void SFXPOP3Receiver::SetLimit(UInt32 limit)
{
    _limit = limit;
}// SFXPOP3Receiver::SetLimit //

/*public */inline Void SFXPOP3Receiver::SetNumberOfLines(SInt32 number)
{
    _line = number;
}// SFXPOP3Receiver::SetNumberOfLines //

/*public */inline SFCError SFXPOP3Receiver::Receive(CallbackSPP spp, VoidPtr reference)
{
    return Receive(null, false, spp, reference);
}// SFXPOP3Receiver::Receive //

/*public */inline SFCError SFXPOP3Receiver::Delete(CallbackSPP spp, VoidPtr reference)
{
    return Delete(null, false, spp, reference);
}// SFXPOP3Receiver::Delete //

/*public */inline SFXPOP3Receiver::MailArrayConstRef SFXPOP3Receiver::GetReceivedMailArray(Void) const
{
    return _receivedMailArray;
}// SFXPOP3Receiver::GetReceivedMailArray //

#define     XALLBACK_IMPLEMENT_SFXPOP3RECEIVER(TYPE, FUNCTION, ERROR)           XALLBACK_IMPLEMENT_SFXPOP3(TYPE, FUNCTION, ERROR)

#endif // __SOPHIAFRAMEWORK_SFXPOP3RECEIVER_IHPP //


/***************************************************************************************
****************************************************************************************
***
***     File            : SFXPOP3Receiver.i.cpp
***
****************************************************************************************
****************************************************************************************/

#include <SFXProtocol/SFXMail/SFXPOP3Receiver.h.hpp>

/*public */SFXPOP3Receiver::SFXPOP3Receiver(Void) : _state(STATE_STANDBY), _progress(PROGRESS_NONE), _line(-1), _limit(0), _targetUidlArray(null), _isAutoDelete(false), _deleteCandNum(0), _noUidl(false), _auth(AUTH_NONE), _numSizeList(null), _numUidlList(null), _isSSL(false), _sslTrustMode(SSL_TRUST_MODE_FAIL)
{
}// SFXPOP3Receiver::SFXPOP3Receiver //

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

/*public */Void SFXPOP3Receiver::Cancel(Void)
{
    _state = STATE_STANDBY;
    _progress = PROGRESS_NONE;
    _spp = null;
    _reference = null;
    _pop3.Close();
    Clear();
    return;
}// SFXPOP3Receiver::Cancel //

/*public */Void SFXPOP3Receiver::Clear(Void)
{
    MailArray::Iterator itor;
    SFXAnsiStringPtr string;
    MailInfoPtr minfo;

    _server.Set(0, 0);
    _user.Clear();
    _password.Clear();

    itor = _receivedMailArray.GetFirstIterator();
    while (itor.HasNext()) {
        minfo = itor.GetNext();
        ::delete minfo;
    }
    _receivedMailArray.Clear();
    FreeSingleUidl();
    FreeNumSizeList();
    FreeNumUidlList();
    return;
}// SFXPOP3Receiver::Clear //

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

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

/*public */SFCError SFXPOP3Receiver::Receive(SFXAnsiStringConstRef targetUidl, CallbackSPP spp, VoidPtr reference)
{
    SFCError error;

    if (!targetUidl.IsEmpty()) {
        if ((error = SetSingleUidl(targetUidl)) == SFERR_NO_ERROR) {
            error = Receive(&_singleUidlArray, false, spp, reference);
        }
    }
    else {
        error = SFERR_INVALID_PARAM;
    }
    return error;
}// SFXPOP3Receiver::Receive //

/*public */SFCError SFXPOP3Receiver::Receive(UidlArrayPtr targetUidlArray, Bool invertTarget, CallbackSPP spp, VoidPtr reference)
{
    SFCError error;

    if (_state == STATE_STANDBY) {
        _targetUidlArray = targetUidlArray;
        _invertTarget = invertTarget;
        _apop = false;
        _spp = spp;
        _reference = reference;
        _pop3.Close();
        if ((error = _pop3.Open()) == SFERR_NO_ERROR) {
            _pop3.SetSSLMode(_isSSL);
            if ((error = _pop3.SetTrustMode(_sslTrustMode)) == SFERR_NO_ERROR) {
                if ((error = _pop3.Connect(_server, XALLBACK_INTERNAL(OnPOP3Receive))) == SFERR_NO_ERROR) {
                    _state = STATE_RECEIVING;
                    _progress = PROGRESS_CONNECT;
                }
            }
            if (error != SFERR_NO_ERROR) {
                _pop3.Close();
            }
        }
    }
    else {
        error = SFERR_INVALID_STATE;
    }
    return error;
}// SFXPOP3Receiver::Receive //

/*public */SFCError SFXPOP3Receiver::Delete(SFXAnsiStringConstRef uidl, CallbackSPP spp, VoidPtr reference)
{
    SFCError error;

    if (!uidl.IsEmpty()) {
        if ((error = SetSingleUidl(uidl)) == SFERR_NO_ERROR) {
            error = Delete(&_singleUidlArray, false, spp, reference);
        }
    }
    else {
        error = SFERR_INVALID_PARAM;
    }
    return error;
}// SFXPOP3Receiver::Delete //

/*public */SFCError SFXPOP3Receiver::Delete(UidlArrayPtr targetUidlArray, Bool invertTarget, CallbackSPP spp, VoidPtr reference)
{
    SFCError error;

    if (_state == STATE_STANDBY) {
        _targetUidlArray = targetUidlArray;
        _invertTarget = invertTarget;
        _spp = spp;
        _reference = reference;
        _pop3.Close();
        if ((error = _pop3.Open()) == SFERR_NO_ERROR) {
            _pop3.SetSSLMode(_isSSL);
            if ((error = _pop3.SetTrustMode(_sslTrustMode)) == SFERR_NO_ERROR) {
                if ((error = _pop3.Connect(_server, XALLBACK_INTERNAL(OnPOP3Delete))) == SFERR_NO_ERROR) {
                    _state = STATE_RECEIVING;
                    _progress = PROGRESS_CONNECT;
                }
            }
            if (error != SFERR_NO_ERROR) {
                _pop3.Close();
            }
        }
    }
    else {
        error = SFERR_INVALID_STATE;
    }
    return error;
}// SFXPOP3Receiver::Delete //

/*private */XALLBACK_IMPLEMENT_SFXPOP3(SFXPOP3Receiver, OnPOP3Receive, error)
{
    Bool next;

    if (error == SFERR_NO_ERROR) {
        switch (_progress) {
            case PROGRESS_CONNECT:
                error = ProceedConnect();
                break;
            case PROGRESS_USER:
                error = ProceedUser();
                break;
            case PROGRESS_PASS:
                error = ProceedPass();
                break;
            case PROGRESS_LIST:
                error = ProceedList();
                break;
            case PROGRESS_UIDL:
                error = ProceedUidl(true);
                break;
            case PROGRESS_RETR:
            case PROGRESS_TOP:
                error = ProceedReceivingRetr();
                break;
            case PROGRESS_DELE:
                if (_pop3.IsResponseOk()) {
                    if ((error = ReceiveNextMail(&next)) == SFERR_NO_ERROR) {
                        if (!next) {
                            _progress = PROGRESS_QUIT;
                            error = _pop3.SendQuitCommand();
                        }
                    }
                }
                else {
                    error = SFERR_FAILED;
                }
                break;
            case PROGRESS_QUIT:
                if (_pop3.IsResponseOk()) {
                    _progress = PROGRESS_DONE;
                    Finish(SFERR_NO_ERROR);
                }
                else {
                    error = SFERR_FAILED;
                }
                break;
            case PROGRESS_DONE:
            case PROGRESS_NONE:
            default:
                error = SFERR_FAILED;
                break;
        }
    }
    if (error != SFERR_NO_ERROR) {
        Finish(error);
    }
    return;
}// XALLBACK_IMPLEMENT_SFXPOP3(SFXPOP3Receiver, OnPOP3, error) //

/*private */SFCError SFXPOP3Receiver::ProceedConnect(Void)
{
    SFCError error;

    if (_auth == AUTH_NONE || _user.IsEmpty() && _password.IsEmpty()) {
// skip user authorization
        _progress = PROGRESS_LIST;
        error = _pop3.SendListCommand();
    }
    else {
        error = SendAuthCommand();
    }
    return error;
}// SFXPOP3Receiver::ProceedConnect //

/*private */SFCError SFXPOP3Receiver::ProceedUser(Void)
{
    SFCError error;

    if (_pop3.IsResponseOk()) {
        _progress = PROGRESS_PASS;
        error = _pop3.SendPassCommand(_password);
    }
    else {
        error = SFERR_FAILED;
    }
    return error;
}// SFXPOP3Receiver::ProceedUser //

/*private */SFCError SFXPOP3Receiver::ProceedPass(Void)
{
    SFCError error;

    if (_pop3.IsResponseOk()) {
        _progress = PROGRESS_LIST;
        error = _pop3.SendListCommand();
    }
    else {
        if (_apop && _auth == AUTH_APOP_AND_USERPASS) {
// The server does not support APOP.
            _apop = false;
            _progress = PROGRESS_USER;
            error = _pop3.SendUserCommand(_user);
        }
        else {
            error = SFERR_MAIL_INVALID_PASSWORD;
        }
    }
    return error;
}//SFXPOP3Receiver::ProceedPass //

/*private */SFCError SFXPOP3Receiver::ProceedList(Void)
{
    SFCError error;

    if (_pop3.IsResponseOk()) {
        FreeNumSizeList();
        if ((error = _pop3.GetListResponse(&_numSizeList, &_numSizeCount)) == SFERR_NO_ERROR) {
            if (_numSizeCount > 0) {
                _progress = PROGRESS_UIDL;
                error = _pop3.SendUidlCommand();
            }
            else {
                _progress = PROGRESS_QUIT;
                error = _pop3.SendQuitCommand();
            }
        }
    }
    else {
        error = SFERR_FAILED;
    }
    return error;
}// SFXPOP3Receiver::ProceedList //

/*private */SFCError SFXPOP3Receiver::ProceedUidl(Bool receiving)
{
    SFCError error(SFERR_NO_ERROR);
    Bool nextMail(false);

    if (!_pop3.IsResponseOk()) {
        if (_targetUidlArray == null && !_invertTarget) {
            _noUidl = true; // The server is not support uidl command.
        }
        else {
            error = SFERR_MAIL_NOT_SUPPORT_UIDL;
        }
    }
    if (error == SFERR_NO_ERROR) {
        FreeNumUidlList();
        if (!_noUidl) {
            error = _pop3.GetUidlResponse(&_numUidlList, &_numUidlCount);
        }
        else {
            _numUidlCount = _numSizeCount;
        }
        if (error == SFERR_NO_ERROR) {
            if (!receiving || _numUidlCount > 0) {
                _index = 0;
                _numSizeIndex = 0;
                error = (receiving) ? (ReceiveNextMail(&nextMail)) : (DeleteNextMail(&nextMail));
            }
            if (error == SFERR_NO_ERROR) {
                if (!nextMail) {
                    error = _pop3.SendQuitCommand();
                }
            }
        }
    }
    return error;
}// SFXPOP3Receiver::ProceedUidl //

/*private */SFCError SFXPOP3Receiver::ProceedReceivingRetr(Void)
{
    SFCError error(SFERR_NO_ERROR);
    MailInfoPtr minfo;
    Bool next;

    if (_pop3.IsResponseOk()) {
        if ((minfo = ::new MailInfo) != null) {
            if ((error = _receivedMailArray.InsertLast(minfo)) == SFERR_NO_ERROR) {
                minfo->size = _nextMailInfo.size;
                if ((error = minfo->uidl.Set(_nextMailInfo.uidl)) == SFERR_NO_ERROR) {
                    if (_progress == PROGRESS_RETR) {
                        error = _pop3.GetRetrResponse(&minfo->mail);
                    }
                    else {
                        error = _pop3.GetTopResponse(&minfo->mail);
                    }
                    if (error == SFERR_NO_ERROR) {
                        ++_index;
                        if (_isAutoDelete) {
                            _progress = PROGRESS_DELE;
                            error = _pop3.SendDeleCommand(_deleteCandNum);
                        }
                        else {
                            if ((error = ReceiveNextMail(&next)) == SFERR_NO_ERROR) {
                                if (!next) {
                                    _progress = PROGRESS_QUIT;
                                    error = _pop3.SendQuitCommand();
                                }
                            }
                        }
                    }
                }
            }
            if (error != SFERR_NO_ERROR) {
                ::delete minfo;
            }
        }
        else {
            error = SFERR_NO_MEMORY;
        }
    }
    else {
        error = SFERR_FAILED;
    }
    return error;
}// SFXPOP3Receiver::ProceedReceivingRetr //

/*private */SFCError SFXPOP3Receiver::ReceiveNextMail(BoolPtr next)
{
    SFCError error(SFERR_NO_ERROR);
    SInt32 number;

    if (_limit > 0 && _index >= _limit) {
        *next = false;
    }
    else {
        if ((number = FindNextTarget()) > -1) {
            _deleteCandNum = number;
            if (_line < 0) {
                _progress = PROGRESS_RETR;
                error = _pop3.SendRetrCommand(number);
            }
            else {
                _progress = PROGRESS_TOP;
                error = _pop3.SendTopCommand(number, _line);
            }
            *next = true;
        }
        else {
            *next = false;
        }
    }
    return error;
}// SFXPOP3Receiver::ReceiveNextMail //

/*private */XALLBACK_IMPLEMENT_SFXPOP3(SFXPOP3Receiver, OnPOP3Delete, error)
{
    Bool next;

    if (error == SFERR_NO_ERROR) {
        switch (_progress) {
            case PROGRESS_CONNECT:
                error = ProceedConnect();
                break;
            case PROGRESS_USER:
                error = ProceedUser();
                break;
            case PROGRESS_PASS:
                error = ProceedPass();
                break;
            case PROGRESS_LIST:
                error = ProceedList();
                break;
            case PROGRESS_UIDL:
                error = ProceedUidl(false);
                break;
            case PROGRESS_DELE:
                if (_pop3.IsResponseOk()) {
                    if ((error = DeleteNextMail(&next)) == SFERR_NO_ERROR) {
                        if (!next) {
                            _progress = PROGRESS_QUIT;
                            error = _pop3.SendQuitCommand();
                        }
                    }
                }
                else {
                    error = SFERR_FAILED;
                }
                break;
            case PROGRESS_QUIT:
                if (_pop3.IsResponseOk()) {
                    _progress = PROGRESS_DONE;
                    Finish(SFERR_NO_ERROR);
                }
                else {
                    error = SFERR_FAILED;
                }
                break;
            case PROGRESS_RETR:
            case PROGRESS_TOP:
            case PROGRESS_DONE:
            case PROGRESS_NONE:
            default:
                error = SFERR_FAILED;
                break;
        }
    }
    if (error != SFERR_NO_ERROR) {
        Finish(error);
    }
    return;
}// XALLBACK_IMPLEMENT_SFXPOP3(SFXPOP3Receiver, OnPOP3, error) //

/*private */SFCError SFXPOP3Receiver::DeleteNextMail(BoolPtr next)
{
    SFCError error(SFERR_NO_ERROR);
    SInt32 number;

    if ((number = FindNextTarget()) > -1) {
        _progress = PROGRESS_DELE;
        error = _pop3.SendDeleCommand(number);
        *next = true;
    }
    else {
        *next = false;
    }
    return error;
}// SFXPOP3Receiver::DeleteNextMail //

/*private */Void SFXPOP3Receiver::Finish(SFCError error)
{
    _state = STATE_STANDBY;
    FreeNumSizeList();
    FreeNumUidlList();
    _pop3.Close();
    if (_spp != null) {
        _spp(error, _reference);
    }
    return;
}// SFXPOP3Receiver::Finish //

/*private */SFCError SFXPOP3Receiver::SetSingleUidl(SFXAnsiStringConstRef uidl)
{
    SFCError error;
    SFXAnsiStringPtr string;

    FreeSingleUidl();
    if ((string = ::new SFXAnsiString(uidl)) != null) {
        if ((error = _singleUidlArray.InsertLast(string)) != SFERR_NO_ERROR) {
            ::delete string;
        }
    }
    else {
        error = SFERR_NO_MEMORY;
    }
    return error;
}// SFXPOP3Receiver::SetSingleUidl //

/*private */Void SFXPOP3Receiver::FreeNumSizeList(Void)
{
    if (_numSizeList != null) {
        ::delete [] _numSizeList;
        _numSizeList = null;
        _numSizeCount = 0;
    }
    return;
}// SFXPOP3Receiver::FreeNumSizeList //

/*private */Void SFXPOP3Receiver::FreeNumUidlList(Void)
{
    if (_numUidlList != null) {
        ::delete [] _numUidlList;
        _numUidlList = null;
        _numUidlCount = 0;
    }
    return;
}// SFXPOP3Receiver::FreeNumUidlList //

/*private */Void SFXPOP3Receiver::FreeSingleUidl(Void)
{
    UidlArray::Iterator itor;

    if (!_singleUidlArray.IsEmpty()) {
        itor = _singleUidlArray.GetFirstIterator();
        while (itor.HasNext()) {
            ::delete itor.GetNext();
        }
        _singleUidlArray.Clear();
    }
    return;
}// SFXPOP3Receiver::FreeSingleUidl //

/*private */Bool SFXPOP3Receiver::IsTargetUidl(SFXAnsiStringConstRef uidl)
{
    Bool result(false);
    SInt32 r0;

    if (_targetUidlArray == null) {
        result = true;
    }
    else {
        for (r0 = 0; r0 < _targetUidlArray->GetSize(); ++r0) {
            if (_targetUidlArray->Get(r0)->Equals(uidl)) {
                break;
            }
        }
        result = (r0 < _targetUidlArray->GetSize());
        if (_invertTarget) {
            result = !result;
        }
    }
    return result;
}// SFXPOP3Receiver::IsTargetUidl //

/*private */SInt32 SFXPOP3Receiver::FindNextTarget(Void)
{
    SInt32 result(-1);
    UInt32 number;
    UInt32 size;
    SInt32 r0;

    if (_noUidl) {
        if (_numSizeIndex < _numSizeCount) {
            _nextMailInfo.size = _numSizeList[_numSizeIndex].size;
            _nextMailInfo.uidl.Clear();
            _nextMailInfo.mail.Clear();
            ++_numSizeIndex;
            result = _numSizeIndex;
        }
    }
    else {
        for (; _numSizeIndex < _numSizeCount; ++_numSizeIndex) {
            number = _numSizeList[_numSizeIndex].number;
            size = _numSizeList[_numSizeIndex].size;
            for (r0 = 0; r0 < _numUidlCount; ++r0) {
                if (_numUidlList[r0].number == number) {
                    if (IsTargetUidl(_numUidlList[r0].uidl)) {
                        _nextMailInfo.size = size;
                        _nextMailInfo.uidl = _numUidlList[r0].uidl;
                        _nextMailInfo.mail.Clear();
                        ++_numSizeIndex;
                        result = number;
                        break;
                    }
                }
            }
            if (result > -1) {
                break;
            }
        }
    }
    return result;
}// SFXPOP3Receiver::FindNextTarget //

/*private */SFCError SFXPOP3Receiver::SendAuthCommand(Void)
{
    SFCError error(SFERR_NO_ERROR);
    SFXAnsiString challenge;
    SInt32 start, end;

    switch (_auth) {
        case AUTH_APOP_AND_USERPASS:
        case AUTH_ONLY_APOP:
            _apop = true;
            _progress = PROGRESS_PASS;
            if ((error = challenge.Set(_pop3.GetResponseText())) == SFERR_NO_ERROR) {
                if ((start = challenge.FirstIndexOf('<')) >= 0) {
                    if ((end = challenge.LastIndexOf('>')) >= 0) {
                        error = _pop3.SendApopCommand(_user, _password, challenge.Substring(start, end));
                    }
                    else {
                        error = SFERR_FAILED;
                    }
                }
                else {
                    error = SFERR_FAILED;
                }
            }
            break;
        case AUTH_ONLY_USERPASS:
            _progress = PROGRESS_USER;
            error = _pop3.SendUserCommand(_user);
            break;
        case AUTH_NONE:
        default:
            break;
    }
    return error;
}// SFXPOP3Receiver::SendAuthCommand //