gclientprotocol.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_SMTP_CLIENT_PROTOCOL_H
#define G_SMTP_CLIENT_PROTOCOL_H

#include "gdef.h"
#include "gnet.h"
#include "gsmtp.h"
#include "gmessagestore.h"
#include "gsaslclient.h"
#include "gsecrets.h"
#include "gslot.h"
#include "gstrings.h"
#include "gtimer.h"
#include "gexception.h"
#include <memory>
#include <iostream>

namespace GSmtp
{
        class ClientProtocol ;
        class ClientProtocolReply ;
}

class GSmtp::ClientProtocolReply 
{
public:
        enum Type
        {
                PositivePreliminary = 1 ,
                PositiveCompletion = 2 ,
                PositiveIntermediate = 3 ,
                TransientNegative = 4 ,
                PermanentNegative = 5
        } ;
        enum SubType
        {
                Syntax = 0 ,
                Information = 1 ,
                Connections = 2 ,
                MailSystem = 3 ,
                Invalid_SubType = 4
        } ;
        enum Value
        {
                Internal_2xx = 222 ,
                Internal_2yy = 223 ,
                Internal_2zz = 224 ,
                ServiceReady_220 = 220 ,
                Ok_250 = 250 ,
                Authenticated_235 = 235 ,
                Challenge_334 = 334 ,
                OkForData_354 = 354 ,
                SyntaxError_500 = 500 ,
                SyntaxError_501 = 501 ,
                NotImplemented_502 = 502 ,
                BadSequence_503 = 503 ,
                NotAuthenticated_535 = 535 ,
                NotAvailable_454 = 454 ,
                Invalid = 0
        } ;

        static ClientProtocolReply ok() ;

        static ClientProtocolReply ok( Value ) ;

        static ClientProtocolReply error( const std::string & reason ) ;

        explicit ClientProtocolReply( const std::string & line = std::string() ) ;

        bool add( const ClientProtocolReply & other ) ;

        bool incomplete() const ;

        bool validFormat() const ;

        bool positive() const ;

        bool is( Value v ) const ;

        int value() const ;

        std::string text() const ;

        std::string errorText() const ;

        bool textContains( std::string s ) const ;

        std::string textLine( const std::string & prefix ) const ;

        Type type() const ;

        SubType subType() const ;

private:
        static bool is_digit( char ) ;

private:
        bool m_complete ;
        bool m_valid ;
        int m_value ;
        std::string m_text ;
} ;

class GSmtp::ClientProtocol : private GNet::AbstractTimer 
{
public:
        G_EXCEPTION( NotReady , "not ready" ) ;
        G_EXCEPTION( ResponseError , "protocol error: unexpected response" ) ;
        G_EXCEPTION( NoMechanism , "cannot do authentication mandated by remote server" ) ;
        G_EXCEPTION( AuthenticationRequired , "authentication required by the remote smtp server" ) ;
        G_EXCEPTION( AuthenticationNotSupported , "authentication not supported by the remote smtp server" ) ;
        G_EXCEPTION( AuthenticationError , "authentication error" ) ;
        G_EXCEPTION( TlsError , "tls/ssl error" ) ;
        typedef ClientProtocolReply Reply ;

        class Sender 
        {
                public: virtual bool protocolSend( const std::string & , size_t offset , bool go_secure ) = 0 ;

                private: void operator=( const Sender & ) ; // not implemented
                public: virtual ~Sender() ;
        } ;

        struct Config 
        {
                std::string thishost_name ;
                unsigned int response_timeout ;
                unsigned int ready_timeout ;
                unsigned int preprocessor_timeout ;
                bool must_authenticate ;
                bool must_accept_all_recipients ;
                bool eight_bit_strict ;
                Config( const std::string & , unsigned int , unsigned int , unsigned int , bool , bool , bool ) ;
        } ;

        ClientProtocol( Sender & sender , const GAuth::Secrets & secrets , Config config ) ;

        G::Signal2<std::string,int> & doneSignal() ;

        G::Signal0 & preprocessorSignal() ;

        void start( const std::string & from , const G::Strings & to , bool eight_bit ,
                std::string authentication , std::string server_name ,
                std::auto_ptr<std::istream> content ) ;

        void sendDone() ;

        void preprocessorDone( bool ok , const std::string & reason ) ;

        void secure() ;

        bool apply( const std::string & rx ) ;

protected:
        virtual void onTimeout() ; 

        virtual void onTimeoutException( std::exception & ) ;

private:
        void send( const char * ) ;
        void send( const char * , const std::string & ) ;
        void send( const char * , const std::string & , const char * ) ;
        bool send( const std::string & , bool eot , bool sensitive = false ) ;
        bool sendLine( std::string & ) ;
        size_t sendLines() ;
        void sendEhlo() ;
        void sendHelo() ;
        void sendMail() ;
        void sendMailCore() ;
        bool endOfContent() const ;
        static const std::string & crlf() ;
        bool applyEvent( const Reply & event , bool is_start_event = false ) ;
        static bool parseReply( Reply & , const std::string & , std::string & ) ;
        void raiseDoneSignal( const std::string & , int = 0 , bool = false ) ;
        bool serverAuth( const ClientProtocolReply & reply ) const ;
        G::Strings serverAuthMechanisms( const ClientProtocolReply & reply ) const ;
        void startPreprocessing() ;

private:
        enum State { sInit , sStarted , sServiceReady , sSentEhlo , sSentHelo , sAuth1 , sAuth2 , sSentMail , 
                sPreprocessing , sSentRcpt , sSentData , sSentDataStub , sData , sSentDot , sStartTls , sSentTlsEhlo , sDone } ;
        Sender & m_sender ;
        const GAuth::Secrets & m_secrets ;
        std::string m_thishost ;
        State m_state ;
        std::string m_from ;
        G::Strings m_to ;
        size_t m_to_size ;
        size_t m_to_accepted ;
        std::auto_ptr<std::istream> m_content ;
        bool m_server_has_auth ;
        bool m_server_has_8bitmime ;
        bool m_server_has_tls ;
        bool m_message_is_8bit ;
        std::string m_message_authentication ;
        Reply m_reply ;
        bool m_authenticated_with_server ;
        std::string m_auth_mechanism ;
        std::auto_ptr<GAuth::SaslClient> m_sasl ;
        bool m_must_authenticate ;
        bool m_must_accept_all_recipients ;
        bool m_strict ;
        bool m_warned ;
        unsigned int m_response_timeout ;
        unsigned int m_ready_timeout ;
        unsigned int m_preprocessor_timeout ;
        G::Signal2<std::string,int> m_done_signal ;
        G::Signal0 m_preprocessor_signal ;
} ;

#endif