smtpthread/ThreadedSMTPConnection.cc

// DOCUMENT:  ThreadedSMTPConnection-Class
// VERSION:   $Revision: 1.6 $
// DATE:      $Date: 2007-10-26 23:09:19 $
// AUTHOR:    M.Beranek
// COPYRIGHT: M.Beranek

// TODO: Handle changing connection-data after initConnection...

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "Thread.h"
#include "SMTPConnection.h"
#include "ThreadedSMTPConnection.h"

using namespace std;

namespace SmtpThread
{
// --------------------------------------------------------------------------
    /**
     * Default-Constructor.
     * Initalizes all values to connect to "127.0.0.1", port 25 and
     * identifies ourself as "localhost".
     * The connection is not opened until a mail is sent.
     */
    ThreadedSMTPConnection::ThreadedSMTPConnection()
    {
        _isReady = false;
        _smtp = SMTPConnection::NOT_CONNECTED;
        _host = "127.0.0.1";
        _port = 25;
        _myname = "localhost";
        _hasMail = false;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Starts execution of SMTP-connection-handler.
     */
    void ThreadedSMTPConnection::Execute( void * arg )
    {
        // cout << "Start threading... " << endl;
        
        _isReady = true;
        
        // endless loop while running:
        while( _isRunning )
        {
            // Assume that we have all connection-data provided,
            // so let's open a connection. If connection is opened
            // already, the connection won't change.
            // _smtpCon.openConnection();
            
            // If someone put a mail into our object:
            if( _hasMail )
            {
                //cout << "Setting Lock" << endl;
                
                // Begin Critical section:
                getLock();
                
                // cout << "Calling SMTPConnection.sendMail" << endl;
                
                // Set mail-parameters:
                _smtpCon.sendMail( _from, _to, _body );
                
                // Status zurücksetzen:
                _hasMail = false;
                _isReady = true;
                
                // Send the message:
                // _smtpCon.sendSMTPMessage();
                
                // End Critical section:
                releaseLock();
                
                // cout << "Releasing Lock" << endl;
                
            }
            
            // wait a few micro-seconds:
            // 1s    = 1000000
            // 0.5s  =  500000
            // 0.25s =  250000
            usleep( 250000 );
            
        }
        
        // if we are terminated before all mails were sent:
        if( (! _isRunning) && _hasMail )
        {
            
            // QUESTION: critical section or not?
            
            // Begin Critical section:
            getLock();
            
            // send the last mail:
            _smtpCon.sendMail( _from, _to, _body );
            // _smtpCon.sendSMTPMessage();
            
            _hasMail = false;
            
            // End critical section
            releaseLock();
            
        }
        
        // if we have stopped:
        if( ! _isRunning )
        {
            _smtpCon.disconnect();
        }
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Returns true, if the connection is ready to accept messages.
     * If the connection currently delivers mail, returns false.
     *
     * @return bool true / false = ready / not ready to accepting mail.
     */
    bool ThreadedSMTPConnection::isReady()
    {
        return _isReady;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Gets the current SMTP-State.
     *
     * Possible values are:
     * STATE_NOT_CONNECTED, STATE_CONNECTED, STATE_HELO, STATE_MAILFROM,
     * STATE_RCPTTO, STATE_DATA, STATE_DATA_SENDING
     *
     * @return int SMTP-State.
     */
    SMTPConnection::SMTPState ThreadedSMTPConnection::getSMTPState()
    {
        return _smtpCon.getSMTPState();
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Accepts a new email to be send via SMTP.
     *
     * The email-body should contain additional headers like subject etc.
     *
     * @param string* from sender-email
     * @param string* to receiverr-email
     * @param string* msg email-body
     *
     */
    void ThreadedSMTPConnection::sendMail( string& from, string& to, string& msg )
    {
        if( _isReady )
        {
            // cout << "ThreadedSMTPConnection::sendMail" << endl;
            // Critical section begins:
            getLock();
            
            _isReady = false;
            _from = from;
            _to   = to;
            _body = msg;
            _hasMail = true;
            
            // End of critical section:
            releaseLock();
        }
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sets the SMTP-Host (IP).
     *
     * @param string host IP-Address of the SMTP-host.
     */
    void ThreadedSMTPConnection::setSMTPHost( string host )
    {
        // cout << "ThreadedSMTPConnection::setSMTPHost" << endl;
        
        // Begin critical section:
        getLock();
        
        // Set SMTP-host:
        _host = host;
        _smtpCon.setSMTPHost( _host );
        
        // End critical section:
        releaseLock();
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sets the Port to connect to, defaults to 25.
     *
     * @param int port Port
     *
     */
    void ThreadedSMTPConnection::setSMTPPort( int port )
    {
        // Begin critical section:
        getLock();
        // cout << "ThreadedSMTPConnection::setSMTPPort" << endl;
        
        // Set port:
        _port = port;
        _smtpCon.setSMTPPort( _port );
        
        // End critical section:
        releaseLock();
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sets the name, wich will be send with the "HELO"-command.
     */
    void ThreadedSMTPConnection::setMyHostname( string myname )
    {
        // cout << "ThreadedSMTPConnection::setMyHostname" << endl;
        
        // Begin critical section:
        getLock();
        
        // Set the HELO-name:
        _myname = myname;
        _smtpCon.setMyHostname( _myname );
        
        // End critical section:
        releaseLock();
        
    }
    
}

---