---

Milter.hh

Go to the documentation of this file.

/*
 * Milter.hh
 *
 * Copyright 2001, LifeLine Networks bv (www.lifeline.nl). All rights reserved.
 * Copyright 2001, Bastiaan Bakker. All rights reserved.
 *
 * See the COPYING file for the terms of usage and distribution.
 */

#ifndef _sendmail_milter_Milter_hh
#define _sendmail_milter_Milter_hh
#include <sys/types.h>
#include <stdlib.h>

struct smfi_str;
typedef struct smfi_str SMFICTX;
class sockaddr;

namespace sendmail {
    namespace milter {

        enum Decision {
            CONTINUE = 0, 
            REJECT   = 1, 
            DISCARD  = 2, 
            ACCEPT   = 3,
            TEMPFAIL = 4,
        };

        class CallbackFactory;

        class Milter {
            public:

            Milter(const char* name, CallbackFactory* factory,
                   const char* connection, int timeout = 1800);
            virtual ~Milter();

            virtual const CallbackFactory& getCallbackFactory() const;

            virtual CallbackFactory& getCallbackFactory();

            virtual void start();

            virtual void stop();

            virtual void setDebug(int debug);

            protected:
            virtual void _registerMilter(const char* name,
                                         CallbackFactory* factory,
                                         const char* connection, 
                                         int timeout);
        };

        class ConnectionCallbackInterface {
            public:
            virtual ~ConnectionCallbackInterface() {};

            virtual Decision connect(const char* hostname, 
                                     const struct sockaddr* hostaddr) = 0;
            virtual Decision helo(const char* helohost) = 0;
            virtual Decision close() = 0;
        };

        class MessageCallbackInterface {
            public:
            virtual ~MessageCallbackInterface() {};
            
            virtual Decision envelopeFrom(const char** argv) = 0;
            virtual Decision envelopeRcpt(const char** argv) = 0;
            virtual Decision header(const char* headerField,
                                    const char* headerValue) = 0;
            virtual Decision endOfHeaders() = 0;
            virtual Decision body(const unsigned char* bodyData, 
                                  size_t length) = 0;
            virtual Decision endOfMessage() = 0;
            virtual Decision abortMessage() = 0;
        };
        
        class CallbackInterface :
            virtual public ConnectionCallbackInterface,
            virtual public MessageCallbackInterface {
            public:
            virtual ~CallbackInterface() {};
        };
        
        struct ContextHolder {
            SMFICTX* _context;
        };

        class DataAccess :
            virtual protected ContextHolder 
        {
            public:
            DataAccess();
            DataAccess(SMFICTX* context);
            virtual ~DataAccess();
            
            virtual const char* getMacroValue(const char* macroName);

            virtual void setReplyCode(const char* rCode,
                                      const char* xCode = NULL,
                                      const char* message = NULL);
        };
        
        class MessageModification :
            virtual protected ContextHolder 
        {
            public:
            MessageModification();
            MessageModification(SMFICTX* context);
            virtual ~MessageModification();
            virtual void addHeader(const char* headerField, 
                                   const char* headerValue);
            virtual void changeHeader(const char* headerField,
                                      unsigned int headerIndex,
                                      const char* headerValue);
            virtual void deleteHeader(const char* headerField,
                                      unsigned int headerIndex);
            virtual void addRecipient(const char* recipient);
            virtual void deleteRecipient(const char* recipient);
            virtual void replaceBody(const unsigned char* bodyData,
                                     size_t length);
        };

        class CallbackSkeleton :
            virtual public CallbackInterface,
            virtual public DataAccess,
            virtual public MessageModification,
            virtual protected ContextHolder
        {
            public:
            CallbackSkeleton(SMFICTX* context);
            ~CallbackSkeleton();

            virtual Decision connect(const char* hostname, 
                                     const struct sockaddr* hostaddr);
            virtual Decision helo(const char* helohost);
            virtual Decision close();

            virtual Decision envelopeFrom(const char** argv);
            virtual Decision envelopeRcpt(const char** argv);
            virtual Decision header(const char* headerField,
                                    const char* headerValue);
            virtual Decision endOfHeaders();
            virtual Decision body(const unsigned char* bodyData, 
                                  size_t length);
            virtual Decision endOfMessage();
            virtual Decision abortMessage();
        };

        enum ModificationFlag {
            MOD_ADDHDRS = 0x00000001,
            MOD_CHGBODY = 0x00000002,
            MOD_ADDRCPT = 0x00000004,
            MOD_DELRCPT = 0x00000008,
            MOD_CHGHDRS = 0x00000010
        };

        enum CallbackFlag {
            CALLBACK_CONNECT = 0x00000001,
            CALLBACK_HELO    = 0x00000002,
            CALLBACK_ENVFROM = 0x00000004,
            CALLBACK_ENVRCPT = 0x00000008,
            CALLBACK_HEADER  = 0x00000010,
            CALLBACK_EOH     = 0x00000020,
            CALLBACK_BODY    = 0x00000040,
            CALLBACK_EOM     = 0x00000080,
            CALLBACK_ABORT   = 0x00000100,
            CALLBACK_CLOSE   = 0x00000200,
        };

        class CallbackFactory {
            public:
            virtual ~CallbackFactory() {};

            virtual CallbackInterface* newCallback(SMFICTX* context) = 0;
            virtual unsigned long getModificationFlags() const = 0;
            virtual unsigned long getCallbackFlags() const = 0;
        };

        template<class C> class SimpleCallbackFactory :
            virtual public CallbackFactory {
            public:
            SimpleCallbackFactory() {
            };

            virtual CallbackInterface* newCallback(SMFICTX* context) {
                return new C(context);
            };

            virtual unsigned long getModificationFlags() const {
                return C::getModificationFlags();
            };

            virtual unsigned long getCallbackFlags() const {
                return C::getCallbackFlags();
            };
        };

        template<class C> class SimpleMilter :
            public Milter {
            public:
            typedef C CallbackType;
            typedef SimpleCallbackFactory<C> FactoryType;

            SimpleMilter(const char* name, const char* connection, 
                         int timeout) :
                Milter(name, new FactoryType(), connection, timeout) {
            };
        };


        template<class C, class D = typename C::ConfigDataType> class SimpleCallbackFactory2 :
            virtual public CallbackFactory {
            public:
            typedef C CallbackType;
            typedef D ConfigDataType;

            SimpleCallbackFactory2(const ConfigDataType& configData) :
                _configData(configData) {
            };

            virtual CallbackInterface* newCallback(SMFICTX* context) {
                return new C(context, _configData);
            };

            virtual unsigned long getModificationFlags() const {
                return C::getModificationFlags();
            };

            virtual unsigned long getCallbackFlags() const {
                return C::getCallbackFlags();
            };

            virtual const ConfigDataType& getConfigData() const {
                return _configData;
            };

            virtual void setConfigData(const ConfigDataType& configData) {
                _configData = configData;
            };

            protected:
            ConfigDataType _configData;
        };

        template<class C, class D = typename C::ConfigDataType> class SimpleMilter2 :
            public Milter {
            public:
            typedef C CallbackType;
            typedef D ConfigDataType;
            typedef SimpleCallbackFactory2<C, D> FactoryType;

            SimpleMilter2(const char* name, const char* connection, 
                         int timeout, const ConfigDataType& configData) :
                Milter(name, new FactoryType(configData), connection,
                       timeout) {
            };

            virtual const ConfigDataType& getConfigData() const {
                /* XXX don't have a clue why I can't get static_casts to
                   work here.
                */
                const FactoryType* factory =  
                    dynamic_cast<const FactoryType*>(&getCallbackFactory());
                return factory->getConfigData();
            };

            virtual void setConfigData(const ConfigDataType& configData) {
                /* XXX don't have a clue why I can't get static_casts to
                   work here.
                */
                FactoryType* factory =  
                    dynamic_cast<FactoryType*>(&getCallbackFactory());
                factory->setConfigData(configData);            
            };
        };

        extern CallbackFactory* _callbackFactory;

    } // namespace milter
} // namespace sendmail

#endif

---