wlcacheddb.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.             *
 ***************************************************************************/
#include <iostream>
#include <syslog.h>
#include <string.h>
#include <algorithm>
#include <cctype>
#include "wlcacheddb.h"
#include "dbdefs.h"
#include "pmatcher.h"

using namespace std;

#define WLCACHEDDBDBG   false
#define WLCACHEDMATCHDBG        false

WlCachedDB::WlCachedDB(class DB& db,
                bool initmode,
                const WLStaticDef& staticDef) throw(std::exception)
        : _db(db),
          _staticDef(staticDef)
{
        if(initmode) {
                        _db.createTable(_staticDef);
        } //else really
        dbi_result result = _db.executeSQL(_staticDef._testTable);
        if(!result) //table does not exist, error has been logged
                return;
        // this is required in older versions of libdbi -- otherwise no fieldnames
        unsigned numrows = dbi_result_get_numrows(result);
        if(numrows == 0) {
                dbi_result_free(result);
                return;
        }
        dbi_result_next_row(result);
        unsigned numfields = dbi_result_get_numfields(result);
        if(WLCACHEDDBDBG)
                cout << "numfields: " << numfields << endl;
        unsigned primaryIdx = numfields;
        for(unsigned i=0;i < numfields;i++) {
                const char* colname = dbi_result_get_field_name(result,i+1);
                if(WLCACHEDDBDBG)
                        cout << i << ": " << colname << endl;
                if(strcmp(colname,_staticDef._primaryKey) == 0)
                        primaryIdx = i;
                else
                        _heading.insert(Heading::value_type(colname,i));
        }
        if(primaryIdx >= numfields) {
                dbi_result_free(result);
                throw runtime_error(string("WlCachedDb no primary idx in table ")+_staticDef._tableName);
        }
        for(unsigned i=0;i < numrows;i++) {
                string lowerKey( dbi_result_get_string_idx(result,primaryIdx+1) );
                transform( lowerKey.begin(), lowerKey.end(), lowerKey.begin(), ToLower());
                if(WLCACHEDDBDBG)
                        cout << "row: " << i << " key: " << lowerKey << endl;
                Entry row;
                for(Heading::const_iterator itr=_heading.begin();itr != _heading.end();++itr) {
                        string lowerVal; 
                        const char *val = dbi_result_get_string_idx(result,itr->second+1);
                        if(val)
                                lowerVal = val;
                        else
                                lowerVal = "";
                        transform( lowerVal.begin(), lowerVal.end(), lowerVal.begin(), ToLower());
                        if(WLCACHEDDBDBG)
                                cout << "idx: " << itr->second << " val: " << val << endl;
                        row.insert(Entry::value_type(itr->second,lowerVal));
                }
                _data.insert(Data::value_type("'"+lowerKey+"'",row)); //quote the key, see patternMatch before changig
                if(dbi_result_next_row(result) == 0)
                        break;
        }
        dbi_result_free(result);
}
bool WlCachedDB::check(const class Triplet& triplet) throw(std::exception) 
{
        switch(_staticDef._compareMode) {
                case WlModule::CM_exactMatch:
                        return exactMatch( "wl", triplet );
                case WlModule::CM_patternMatch:
                        return patternMatch( "wl", triplet );
                default:
                        return false;
        }
}       
bool WlCachedDB::exactMatch(const std::string logprefix,const class Triplet& triplet)
{
        //TODO implement for more than one condition
        // we suppose that primary = first select where condition
        string searchfor = triplet.getMember(_staticDef._compares[0]._tripletMember);
        transform( searchfor.begin(), searchfor.end(), searchfor.begin(), ToLower());
        if(WLCACHEDMATCHDBG)
                cout << "exactMatch: " << searchfor << endl;
        // if we'd use multimap for complex search this has to be changed
        Data::const_iterator itr = _data.find(searchfor);
        // now we should process other conditions if they contain OR
        if( itr == _data.end() ) {
                return false;
                /*
                // check if the first condition is not the primary key
                if(strcmp(_staticDef._compares[0]._compareWith, _staticDef._primaryKey) == 0)
                        return false;
                //TODO search through complete table 
                return false;
                */
        }
        logMatch(logprefix,itr,triplet);
        return true;            
}
//TODO cache the complied regexes for subsequent calls
bool WlCachedDB::patternMatch(const std::string logprefix,const class Triplet& triplet)
{
        std::string pattern;
        try {
                PatternMatcher pmatcher(triplet);
                for(Data::const_iterator itr=_data.begin();itr != _data.end();++itr) {
                        //remove leading and trailing quote added in constructor...
                        pattern = itr->first.substr(1,itr->first.size()-2);
        //              cout << "rex: " << pattern << endl; //<< " 2nd:" << itr->second 
                                if( pmatcher.match(pattern) ) {
        //                              cout << "match " << triplet << " ~ "<< pattern << endl;
                                        logMatch(logprefix,itr,triplet);
                                        return true;
                                }
                }
        } catch(exception &e) { //log only if something goes wrong with the regex
                syslog(LOG_ERR,"pattern match failed: '%s' in pattern: %s",
                        e.what(),pattern.c_str());
        }
        return false;
}
void WlCachedDB::logMatch(const std::string& logprefix,Data::const_iterator& itr,const Triplet& triplet) const
{
        string strComment = getRowComment(itr);
        syslog(LOG_INFO,"%s %s: %s -> %s, %s: %s",
                logprefix.c_str(),_staticDef._tableName,triplet.getSender().c_str(),
                triplet.getRecipient().c_str(),triplet.getClientAddress().c_str(),strComment.c_str());
}

string WlCachedDB::getRowComment(Data::const_iterator& itr) const
{
        string strComment;
        Heading::const_iterator cmtitr=_heading.find(_staticDef._commentField);
        if( cmtitr == _heading.end() ) {
                strComment = "(comment field not found in table definition, field: " 
                        + string(_staticDef._commentField) + ")";
        } else {
                Entry::const_iterator eitr = itr->second.find(cmtitr->second);
                if(eitr == itr->second.end())
                        strComment = "(comment not found in row)";
                else
                        strComment = eitr->second;
        }
        return strComment;
}
WlCachedDB::~WlCachedDB()
{
}

---