main.cpp

/***************************************************************************
 *   Copyright (C) 2004 by Michael Moritz                                  *
 *   mimo@restoel.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 2 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <pthread.h>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <syslog.h>
#include "defs.h"
#include "triplet.h"
#include "read.h"
#include "configreader.h"
#include "cfg.h"
#include "db.h"
#include "action.h"
#include "signals.h"
using namespace std;

const static char s_gpsname[] = PACKAGE; //from config.h

typedef out_of_range EndOfInputException;


void usage()
{
        cerr << "usage: gps [-v] configfile" << endl;
}
int end_usage(const std::string& msg)
{
        syslog(LOG_ERR, "Error: %s",msg.c_str());
        cerr << "Error: " << msg << "\n" << endl;
        usage();
        closelog();
        return -1;
}

DB *get_db() {
        DB *greydb = 0;
        // try block for initialising phase
        // - parse config file
        // - connect to db
        try {
//              g_getCfgNonConst().init(reader);
                //FIXME uses global Cfg object!!
                greydb = new DB; 
                if(greydb) {
                        Signal_Handler::instance()->register_handler(SIGINT, greydb);
                        Signal_Handler::instance()->register_handler(SIGTERM, greydb);
                        Signal_Handler::instance()->register_handler(SIGQUIT, greydb);
                }
        // this should not exit, but continue with dunno
        // otherwise we see in the log files:
        //   "warning: problem talking to server private/policy: Success"
        // and a REJECT
        // This usually happens when the db is down
        } catch (exception &e) {
                greydb = 0;
                syslog(LOG_ERR, "error while initialising db: %s, NO GREYLISTING WILL BE DONE",e.what());
        }
        return greydb;
}
void read_config(const std::string filename) {
        syslog(LOG_DEBUG,"reading config: %s",filename.c_str());
        ifstream cfgfile(filename.c_str());
        if(!cfgfile) {
                syslog(LOG_ERR, "error opening config: %s",filename.c_str());
                return;
                //cerr << "Error opening config: " << argv[cfgindex] << ", exiting" << endl;
        }
//      cfgfile.setf(ios::skipws);
        // parse in config file
        
        try {
                ConfigReader reader(cfgfile);
                g_getCfgNonConst().init(reader);
        } catch (exception &e) {
                syslog(LOG_ERR, "error while initialising config: %s",e.what());
        }
}
int main(char argc,char* argv[])
{
//      Watchdog harakiri;
        openlog(::s_gpsname, LOG_PID, GPS_LOG_FACILITY);
        syslog(LOG_INFO,"started (ver.: %s built: %s %s) by %i",VERSION,__DATE__,__TIME__,getppid());
        if(argc < 2)
                return end_usage("too few parameters");

        int cfgindex = 1;
        if(string(argv[1]) == string("-v")) {
                setlogmask(LOG_UPTO(LOG_DEBUG));
                g_getCfgNonConst().setVerbose(true);
                cfgindex = 2;
                if(argc < 3)
                        return end_usage("parameter configfile missing");
        } else {
                setlogmask(LOG_UPTO(LOG_INFO));
        }
        // read configuration file
        // initialise global cfg object
        read_config(argv[cfgindex]);
        
        // create db connection
        // if something goes wrong set to 0     
        DB *greydb = get_db();
        
        // general try block for std::exception
        try { 
                Reader::AttributeSet attrSet;
                attrSet.insert(Reader::AttributeSet::value_type(ATTR_CLIENT,true)); // required input
                attrSet.insert(Reader::AttributeSet::value_type(ATTR_SENDER,true)); // required input
                attrSet.insert(Reader::AttributeSet::value_type(ATTR_RECIPIENT,true)); // required input
                attrSet.insert(Reader::AttributeSet::value_type(ATTR_RCLNAME,false)); // optional, postfix

                while(true) {
                        try {
                                Reader inputReader;
                                int irResult = 0;
                                bool bHaveRequired = false;
//                              do {
                                inputReader.reset();
                                // get the result -- returns -1 if eof
                                irResult = inputReader.parse(attrSet,cin);
                                bHaveRequired = inputReader.haveAllRequired(attrSet);
                                        
                                if((irResult < 0) && !bHaveRequired ) { // eof
                                        if(greydb) {
//                                              greydb->close();
                                                delete greydb;
                                                greydb = 0;
                                        }
                                        closelog();
                                        exit(0);
                                //              throw EndOfInputException("End of File, broken pipe?");
                                }
                                if( g_getCfg().isVerbose() ) {
                                        if( ! bHaveRequired ) {
                                                syslog(LOG_DEBUG,"ignoring garbage: %s", inputReader.getInput().c_str());
                                        } else {
                                                syslog(LOG_DEBUG,"input: %s", inputReader.getInput().c_str());
                                                syslog(LOG_DEBUG,"parsed: %s", inputReader.getParsedString().c_str());
                                        }
                                }
                                // we got something but not what we need
                                if(!bHaveRequired && (irResult != -1) )
                                        continue;
                                        
                                // last check
                                if(!bHaveRequired) 
                                        continue;
                                        
//                              } while(irSize != int(attrSet.size()));
                                // see if something went wrong during init
                                if(!greydb) {
                                        greydb = get_db();
                                        if(!greydb) { 
                                                Action act(Action::dunno); 
                                                continue; //skip greylisting
                                        }
                                }
                                Triplet triplet(inputReader);
                                DB::RecordStatus status = greydb->update(triplet);
                                if(g_getCfg().isModeInit()) {
                                        Action act(Action::dunno);
                                } else {
                                        switch(status) {
                                                default:
                                                case DB::registered:
                                                        { Action act(Action::dunno); }
                                                        break;
                                                case DB::unknown:
                                                case DB::waiting:
                                                        { Action act(Action::defer); }
                                                        break;

                                        }
                                }
                        } catch (EndOfInputException &e) {
                                //throw it on
                                throw e;
                        } catch (exception &e) {
                                syslog(LOG_WARNING, "exception caught: %s, continuing with \'dunno\'",e.what());
                                Action act(Action::dunno);
                        }
                } //while
        } catch (EndOfInputException &e) {
                syslog(LOG_INFO, "FATAL: %s, exiting",e.what());
                return 0;
        } catch (exception &e) {
                syslog(LOG_ERR, "unexcepted error: %s, exiting",e.what());
                Action act(Action::dunno);
                //cerr << "Error while initialising:\n\t" << e.what() << endl;
                closelog();
                return 0;
        }
        return 0;
}

---