smtpthread/SMTPConnection.cc

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

#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"

using namespace std;

namespace SmtpThread
{
// --------------------------------------------------------------------------
    /**
     * Default-Constructor.
     */
    SMTPConnection::SMTPConnection()
    {
        // We are not connected.
        _smtp = NOT_CONNECTED;
        
        // We are using the loopback-interface.
        _host = "127.0.0.1";
        
        // We use the default port.
        _port = 25;
        
        // We are the "localhost".
        _myname = "localhost";
        
        // We do not have a socket-structure yet.
        _remoteEnd = NULL;
        
        // There is no value returned by the SMTP-Server yet.
        _state[0] = 0x0;
        _state[1] = 0x0;
        _state[2] = 0x0;
        _state[3] = 0x0;
        
        
        // We havn't received a single character yet.
        _buf2 = 0x0;
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Destructor.
     */
    SMTPConnection::~SMTPConnection()
    {
        // Be sure, to be disconnected:
        disconnect();
        
        // If socket-structure exists:
        if( _remoteEnd )
            // Clean up socket-structure:
            delete _remoteEnd;
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Gets the current status of the SMTP-Dialog
     * @return SMTPConnection::SMTPState Status of the SMTP-Dialog.
     */
    SMTPConnection::SMTPState SMTPConnection::getSMTPState()
    {
        return _smtp;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sends the email to the server.
     * The actual mail-delivery happens here.
     * @return int error-code: 0 = success, -1 = error
     */
    int SMTPConnection::sendSMTPMessage()
    {
        // status-codes:
        int okay;
        int code;
        
        // counter for attempts:
        int attempts_conn = 0;
        int attempts_init = 0;
        int attempts_from = 0;
        int attempts_to   = 0;
        int attempts_data = 0;
        
        // limits for attempts:
        int max_attempts_conn = 20;
        int max_attempts_init = 5;
        int max_attempts_from = 5;
        int max_attempts_to   = 5;
        int max_attempts_data = 5;
        
        // initialize the connection. If we are connected, this won't do anything.
        initConnection();
        
        
        /*
         **********************************************************
         *
         * A typical SMTP-dialog:
         *
         * 220 voyager.beranek.de ESMTP Postfix
         * HELO beranek.de
         * 250 voyager.beranek.de
         * MAIL From: marcus@beranek.de
         * 250 Ok
         * RCPT To: marcus@voyager.beranek.de
         * 250 Ok
         * DATA
         * 354 End data with <CR><LF>.<CR><LF>
         * bla-blahh...
         * .
         * 250 Ok: queued as ACA6A37B86
         * QUIT
         * 221 Bye
     
         **********************************************************
         */
        
        
        /*
         * Note about the coding-style:
         *
         * The following code looks more like assembler-code,
         * caused by a heavy usage of the "goto"-command.
         *
         * I know a lot of peaople do not like goto's in C/C++,
         * but this is a lot more conveinient than an endless-loop
         * with a very big switch-case-statement...
         *
         */
        
        
        // initialize SMTP-Dialog:
        init:
            
            // cout << "SMTPConnection.sendSMTPMessage: init" << endl;
            
            // Send Reset:
            sendSMTP_CRLF( "RSET");
            
            // Read SMTP-Status-Code:
            code = readSMTPState();
            
            // Say hello:
            sendSMTP( "HELO ");
            
            // Ssend myname:
            sendSMTP_CRLF( _myname );
            
            // Read SMTP-Status-Code:
            code = readSMTPState();
            
            // If SMTP-Statud-Code is not 2xx:
            if( code < 200 || code >= 300)
            {
                
                // We are still connected:
                _smtp = CONNECTED;
                
                // We wait two seconds:
                sleep( 2 );
                
                // We count the attemts:
                attempts_init++;
                
                // If we are within our limits:
                if( attempts_init < max_attempts_init )
                {
                    // retry:
                    goto init;
                }
                // If we are out of the limits:
                else
                {
                    
                    // Close the socket:
                    closeSocket();
                    
                    // Wait a few seconds:
                    sleep(5);
                    
                    // Open socket again:
                    initConnection();
                    
                    // Count the attempts:
                    attempts_conn++;
                    
                    // If we are within our limits:
                    if( attempts_conn < max_attempts_conn )
                    {
                        // Set state:
                        _smtp = CONNECTED;
                        
                        // Go back to HELO:
                        goto init;
                    }
                    // If we are out of the limits:
                    else
                    {
                        // We give up and set state to not-connected:
                        _smtp = NOT_CONNECTED;
                        
                        // Close the socket:
                        closeSocket();
                        
                        // Return an error-code:
                        return -1;
                    }
                }
            }
            
            // We got here, so the HELO-command succeded.
            // We change the state into HELO:
            _smtp = HELO;
            
            // We have to give our email-address:
            mailfrom:
                
                // cout << "SMTPConnection.sendSMTPMessage: mailfrom" << endl;
                
                /*
             
             Command to send:
             "MAIL From: <email@domain.com>"
             
                 */
                
                
                // Send "Mail from <"
                sendSMTP( "MAIL From: <");
                
                // Send the email-address:
                sendSMTP( _from );
                
                // send ">" + CRLF:
                sendSMTP_CRLF( ">" );
                
                // Read SMTP-Status-Code:
                code = readSMTPState();
                
                // If SMTP-state is not 2xx:
                if( code < 200 || code >= 300)
                {
                    
                    // Wait a second:
                    sleep( 1 );
                    
                    // Count the attempts:
                    attempts_from++;
                    
                    // If we are within out limits:
                    if( attempts_from < max_attempts_from )
                    {
                        
                        // We are still in the state HELO::
                        _smtp = HELO;
                        
                        // Try again:
                        goto mailfrom;
                        
                    }
                    // If we are out of the limits:
                    else
                    {
                        
                        // We are still connected:
                        _smtp = CONNECTED;
                        
                        // Go back to "HELO":
                        goto init;
                        
                    }
                }
                
                // If we got here, we have send our email-address successfully.
                // We change the state to MAILFROM:
                _smtp = MAILFROM;
                
                
                // Send email-recipient-address:
                rcptto:
                    
                    // cout << "SMTPConnection.sendSMTPMessage: rcpto" << endl;
                    
                    /*
                 
                 Command to send:
                 "RCPT To: <email@domain>"
                 
                     */
                    
                    // Send "RCPT To: <"
                    sendSMTP( "RCPT To: <" );
                    
                    // Send recipients address:
                    sendSMTP( _to );
                    
                    // Send ">" + CRLF:
                    sendSMTP_CRLF( ">" );
                    
                    // Read SMTP-Status-Code:
                    code = readSMTPState();
                    
                    // If SMTP-state is not 2xx:
                    if( code < 200 || code >= 300)
                    {
                        
                        // Wait a second:
                        sleep( 1 );
                        
                        // Count the attempts:
                        attempts_to++;
                        
                        // If we are within our limits:
                        if( attempts_to < max_attempts_to )
                        {
                            
                            // We are still in the state MAILFROM:
                            _smtp = MAILFROM;
                            
                            // Go backt to MAILFROM
                            goto mailfrom;
                            
                        }
                        // If we are out of limits:
                        else
                        {
                            // We are in the state HELO:
                            _smtp = HELO;
                            
                            // Go back to HELO:
                            goto init;
                            
                        }
                    }
                    
                    // If we got here, we have sent the recipoents address successfully:
                    _smtp = RCPTTO;
                    
                    
                    // Start sending data:
                    data:
                        // cout << "SMTPConnection.sendSMTPMessage: data" << endl;
                        
                        // Command to send: "DATA"
                        sendSMTP_CRLF( "DATA" );
                        
                        // Read SMTP-Status-Code:
                        code = readSMTPState();
                        
                        // The server should return 354:
                        if( code != 354 )
                        {
                            
                            // Wait a second:
                            sleep( 1 );
                            
                            // Count the attempts:
                            attempts_data++;
                            
                            // If we are within our limits:
                            if( attempts_data < max_attempts_data )
                            {
                                
                                // We are still in the state RCPTTO:
                                _smtp = RCPTTO;
                                
                                // Try again
                                goto data;
                                
                            }
                            // If we are out of our limits:
                            else
                            {
                                // We are in the state HELO::
                                _smtp = HELO;
                                
                                // Go back to HELO:
                                goto init;
                            }
                            
                        }
                        
                        // If we got here, the DATA command succeded.
                        // Now we are allowed to send our message.
                        
                        // Chang state to DATA:
                        _smtp = DATA;
                        
                        // send the mailbody:
                        body:
                            
                            // cout << "SMTPConnection.sendSMTPMessage: body" << endl;
                            
                            // Change the state to DATA_SENDING:
                            _smtp = DATA_SENDING;
                            
                            // Send the mail-body:
                            sendSMTP( _body );
                            
                            // End the mail-body with a <CRLF><DOT><CRLF>:
                            sendSMTP_CRLF( "\r\n." );
                            
                            // Read SMTP-Status-Code:
                            code = readSMTPState();
                            
                            // If SMTP-state is not 2xx:
                            if( code <200 || code >= 300)
                            {
                                
                                // Wait a second:
                                sleep( 1 );
                                
                                // Count the attempts:
                                attempts_data++;
                                
                                // If we are within our limits:
                                if( attempts_data < max_attempts_data )
                                {
                                    
                                    // Change state to DATA
                                    _smtp = DATA;
                                    
                                    // Try again:
                                    goto body;
                                    
                                }
                                // If we are out of our limits:
                                else
                                {
                                    
                                    // Chang the state to HELO:
                                    _smtp = HELO;
                                    
                                    // Go back to HELO:
                                    goto init;
                                }
                            }
                            
                            // cout << "SMTPConnection.sendSMTPMessage: finished" << endl;
                            
                            
                            // If we got here, everything went well.
                            // So, we send a reset to start again with
                            // the next message:
                            sendSMTP_CRLF( "RSET" );
                            
                            // Read SMTP-Status-Code:
                            code = readSMTPState();
                            
                            // Change the state to CONNECTED:
                            _smtp = CONNECTED;
                            
                            // Return success-code:
                            return 0;
                            
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sets the SMTP-Host (IP).
     * @param string host IP-Address of the SMTP-host.
     */
    void SMTPConnection::setSMTPHost( string host )
    {
        _host = host;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sets the Port to connect to, defaults to 25.
     * @param int port Port
     */
    void SMTPConnection::setSMTPPort( int port )
    {
        _port = port;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Initializes a connection to the SMTP-server.
     * If a connection is already established, initConnection will
     * silently return and not reset/reinitialize the current connection.
     */
    void SMTPConnection::initConnection()
    {
        // If we don not have a socket-structure:
        if( _remoteEnd == NULL )
            // Initialize a socket-structure.
            initSocket();
        
        // Status of the tcp-connection:
        int connectState = 0;
        
        // If the SMTP-Connection is established, we are not going to re-initialize
        // the socket-structure, because that has happend already.
        if( _smtp == NOT_CONNECTED )
        {
            
            // Initialize socket:
            _tcpSocket = socket(AF_INET, SOCK_STREAM, 0);
            
            // Connect the socket:
            connectState = connect( _tcpSocket, (SA *)_remoteEnd, sizeof (SA) );
            
            // If connection failed:
            if( connectState < 0 )
            {
                
                // Close the socket:
                closeSocket();
                
            }
            
            else
            {
                // Connection succeeded, change the state to CONNECTED:
                _smtp = CONNECTED;
                
                // Read a line from the SMTP-Server and save the SMTP-Status.
                int smtpCode = readSMTPLine();
                
            }
            
            
        }
        
        // If we already have a connection.
        else
        {
            // Nothing to do, so we return.
            return;
        }
        
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Initializes the socket-structure.
     */
    void SMTPConnection::initSocket()
    {
        // Initialize Socket-Structure:
        _remoteEnd = (SAI *) new SA;
        _remoteEnd->sin_family = AF_INET;
        
        // Set IP-Address of Server for the socket-structure:
        _remoteEnd->sin_addr.s_addr = inet_addr( _host.c_str() );
        
        // Set the SMTP-Port for the socket-structure:
        _remoteEnd->sin_port = htons( _port );
        
        // Clear the rest of the socket-structure:
        memset( &(_remoteEnd->sin_zero), '\0', 8 );
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Closes the connection-socket.
     */
    void SMTPConnection::closeSocket()
    {
        // If we have a socket:
        if( _tcpSocket )
        {
            // close it:
            shutdown( _tcpSocket, 2 );
        }
        
        // Change state to NOT_CONNECTED:
        _smtp = NOT_CONNECTED;
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Reads the SMTP-Status from the socket.
     *
     * This method reads the next 3 bytes out of the socket and
     * interprets them as an integer.
     *
     * This method should be called only after sending an SMTP-Command
     * followed by an CRLF to the socket.
     */
    int SMTPConnection::readSMTPState()
    {
        
        /*
         * 'c1' and 'c2' are used as buffer for two following
         * characters of the SMTP-Response. They are initialized
         * with a space. We are reading from the socket untill
         * 'c1' and 'c2' are equal to <CR><LF>.
         */
        char c1 = ' ';
        char c2 = ' ';
        
        // Status-Array:
        char state[4];
        
        // QUESTION: Why not reading into _state directly instead of state?
        
        // Read three characters from the socket and write them to the Status-Array.
        recv( _tcpSocket, state,   1, 0x0 );
        recv( _tcpSocket, state+1, 1, 0x0 );
        recv( _tcpSocket, state+2, 1, 0x0 );
        
        // The 4th entry is a terminating zero.
        state[3] = 0x0;
        
        // Copy the status to class-member.
        _state[0] = state[0];
        _state[1] = state[1];
        _state[2] = state[2];
        _state[3] = state[3];
        
        // Read the rest from the socket, but ignore it.
        
        // As long as we do not have a <CR><LF> (i.e. 0x0D 0x0A:
        while( ! ( ( c1 == 0x0D ) && ( c2 == 0x0A ) ) )
        {
            // Save last character:
            c1 = c2;
            
            // Get next character:
            recv( _tcpSocket, &c2, 1, 0x0 );
            
        }
        
        
        // TODO: Check contents of the state-array for valid characters!
        
        // Calculate status.
        // 'state' contains ASCII-characters,
        // ASCII( '0' ) = 48
        // To get the actual code, we have to remove the
        // ASCII-offset and multiply with 100, 10 and 1...
        
        int code = 100 * (state[0] -48)   // first character  (eg. 354: 3xx =>  3 x 100)
        + 10 * (state[1] -48)             // second character (eg. 354: x5x =>  5 x  10)
        + (state[2] -48);                 // third character  (eg. 354: xx4 =>  4 x   1)
        
        // Return the status-code:
        return code;
        
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sends a command to the SMTP-server (without the terminating CRLF).
     */
    inline int SMTPConnection::sendSMTP( const string msg )
    {
        
        // Send the command:
        return send( _tcpSocket, msg.c_str(), msg.length(), 0x0 );
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sends a command to the SMTP-server followed by the terminating CRLF.
     */
    inline int SMTPConnection::sendSMTP_CRLF( const string msg )
    {
        
        // Send in two stages: first send command, then send <CR><LF>.
        // We cannot send a msg.append( "\r\n" ), because we have a const string!
        
        // Return-values of each stage:
        int ret1 = 0;
        int ret2 = 0;
        
        // Send the command:
        ret1 = sendSMTP( msg );
        
        // Send a <CR><LF>:
        ret2 = sendSMTP( "\r\n" );
        
        // Return result of both return-values:
        return ret1 | ret2;
        
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Reads a line from the socket, stores it into "_buf"
     * and returns the SMTP-Status-Code.
     */
    int SMTPConnection::readSMTPLine()
    {
        
        /*
         * 'c1' and 'c2' are used as buffer for two following
         * characters of the SMTP-Response. They are initialized
         * with a space. We are reading from the socket untill
         * 'c1' and 'c2' are equal to <CR><LF>.
         */
        char c1 = ' ';
        char c2 = ' ';
        
        // Position within our response-line.
        int pos = 0;
        
        
        // As long as we do not have a terminating <CR><LF>:
        while( ! ( (c1 == 0x0D) && (c2 == 0x0A) ) )
        {
            
            // TODO: eleminate _buf2 and use "_buf1 + pos" ...
            
            // Read a character from the socket and store it into _buf2.
            recv( _tcpSocket, &_buf2, 1, 0x0 );
            
            // Save previous last character:
            c1 = c2;
            
            // Save last character:
            c2=_buf2;
            
            // Write last character into buffer:
            _buf1[pos] = c2;
            
            // TODO: Boundary-Check:
            
            // Go one step foreward:
            pos++;
            
            // If we have 999 characters read, we stop reading characters.
            if (pos == 1000)
            {
                // TODO: Get the rest of the date from the socket.
                
                /*
             c1 = 0x0d;
             c2 = 0x0a;
                 */
                
                // Stop processing:
                break;
            }
        }
        
        // Insert a terminating zero-byte into our response-buffer:
        _buf1[pos] = 0x0;
        
        
        // Copy the first three characters into the status-code-buffer:
        _state[0] = _buf1[0];
        _state[1] = _buf1[1];
        _state[2] = _buf1[2];
        _state[3] = 0x0;
        
        // Return the status-code:
        return strtol( _state, NULL, 10 );
        
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Accepts a new email to be send via SMTP.
     *
     * The mailbody should contain all additional headers (like "To", "From",
     * "Subject". "Content-Type" etc.).
     *
     * @param string* from sender-email
     * @param string* to receiverr-email
     * @param string* msg email-body
     */
    int SMTPConnection::sendMail( string& from, string& to, string& msg )
    {
        _from = from;
        _to   = to;
        _body = msg;
        return sendSMTPMessage();
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Sets the name, which will be sent within the "HELO"-command.
     */
    void SMTPConnection::setMyHostname( string myname )
    {
        _myname = myname;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Disconnects from the SMTP-Server.
     *
     * If the socket is connected to a server, we will send a "QUIT"-command to
     * the server, read the SMTP-Status-Code and then close the socket.
     *
     * If the socket is not connected, we do nothing.
     *
     */
    void SMTPConnection::disconnect()
    {
        // If we are connected:
        if( _smtp != NOT_CONNECTED )
        {
            // Be polite and quit the smtp-dialog:
            sendSMTP_CRLF( "QUIT" );
            
            // We clear the socket buffer:
            readSMTPState();
            
            // And finally we close the socket:
            closeSocket();
        }
    }
    
}

---