TacDb.h

// This is part of tacppd project (extended tacacs++ daemon)
// (c) Copyright in 2000-2004 by tacppd team and contributors
// see http://tacppd.org for more information
//
// file: TacDb.h
// description: database adaptation layer

//  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

// modifications:
//

// all comments which start from /** - this is comments for KDoc */
//  for classes
//    @short [short description of the class]
//    @author [class author]
//    @version [class version]
//    @see [references to other classes or methods]
//  for methods
//    @see [references]
//    @return [sentence describing the return value]
//    @exception [list the exeptions that could be thrown]
//    @param [name id] [description]    - can be multiple

#ifndef __TACDB_H__
#define __TACDB_H__

#include "Snmp.h"       // it sometimes required
#include "global.h"

namespace tacpp {

// database table names (this is for version 1 tables)
const string T_DEV = "tacppd_v1_dev";      // network devices table
#define T_USR       "tacppd_v1_usr"        // user/passwords table
#define T_ACC       "tacppd_v1_acc"        // access control
#define T_AVP       "tacppd_v1_avp"        // authorization
#define T_CMD       "tacppd_v1_cmd"        // command authoriz
#define T_ADD       "tacppd_v1_add"        // additional user data
#define T_LOG       "tacppd_v1_log"        // log inform
#define T_TRF       "tacppd_v1_trf"        // intf traffic info
#define T_NF        "tacppd_v1_nf"         // netflow traffic info
#define T_BIL       "tacppd_v1_res"        // resource group
#define T_BILRES    "tacppd_v1_resdata"    // resource group resources
const string T_NFUSR = "tacppd_v1_nfuser"; // user for collect netflow data

#define T_DEV_ID      "DEvice"
#define T_USR_ID      "USer"
#define T_ACC_ID      "ACcess"
#define T_AVP_ID      "AVp"
#define T_CMD_ID      "COmmand"
#define T_ADD_ID      "ADd"
#define T_LOG_ID      "LOg"
#define T_TRF_ID      "TRFInt"
#define T_BIL_ID      "BILLIng"
#define T_BILRES_ID   "BILLRes"
#define T_NFUSR_ID   "NFUser"

#define AVP_SERVICE_LEN   15
#define AVP_PROTOCOL_LEN  15
#define AVP_VALUE_LEN     128

class user_avp {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  string service_;
  string protocol_;
  string avp_;
 public:
  string getService();
  void setService(const string);
  bool compareService(const string);
  string getProtocol();
  void setProtocol(const string);
  bool compareProtocol(const string);
  string getAvp();
  void setAvp(const string);
  void operator =(user_avp);
  bool operator ==(user_avp);
  bool operator !=(user_avp);
  user_avp();
  ~user_avp();
};

const int CMD_AVP_LEN = 50;

class cmd_avp {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  string cmdperm_;
  string cmddeny_;
  string argperm_;
  string argdeny_;
 public:
  string getCmdperm();
  void setCmdperm(const string);
  string getCmddeny();
  void setCmddeny(const string);
  string getArgperm();
  void setArgperm(const string);
  string getArgdeny();
  void setArgdeny(const string);
  void operator =(cmd_avp);
  bool operator ==(cmd_avp);
  cmd_avp();
  ~cmd_avp();
};

#define FROM_PHONE_LEN    64
#define FROM_NAS_LEN      64
#define FROM_PORT_LEN     64
#define FROM_TIME_LEN     64

class db_user_acc {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  string phone_;
  string nas_;
  string port_;
  string time_;
 public:
  string getPhone();
  void setPhone(const string);
  string getNas();
  void setNas(const string);
  string getPort();
  void setPort(const string);
  string getTime();
  void setTime(const string);
  void operator =(db_user_acc);
  bool operator ==(db_user_acc);
  db_user_acc();
  ~db_user_acc();
};

class db_bilres {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  string attribute_;
  string value_;
 public:
  string getAttribute();
  void setAttribute(const string);
  string getValue();
  void setValue(const string);
  void operator =(db_bilres);
  bool operator !=(db_bilres);
  bool operator ==(db_bilres);
  db_bilres();
  ~db_bilres();
};

#define DB_USERNAME_LEN     32
#define DB_AUTHSRC_LEN      5
#define DB_PASSWORD_LEN     50
#define DB_ID_LEN           16
#define MAX_AVP             100
#define MAX_ACC             32
#define MAX_BILRES          32

class db_user {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  string username_;
  string authsrc_;
  string password_;
  string enable_;
  time_t open_;
  time_t close_;
  string avpid_;
  string accid_;
  string addid_;
  string bilid_;
  int bilmodid_;
  list<user_avp> avp_;
  list<cmd_avp> cmd_;
  list<db_user_acc> acc_;
  list<db_bilres> bilres_;
  bool result_;
  bool connect_;
  string result_msg_;
  int maxsess_;
 public:
  db_user();
  ~db_user();
  string getUsername();
  void setUsername(const string);
  string getAuthsrc();
  void setAuthsrc(const string);
  string getPassword();
  void setPassword(const string);
  string getEnable();
  void setEnable(const string);
  time_t getOpen();
  void setOpen(time_t);
  time_t getClose();
  void setClose(time_t);
  string getAvpid();
  void setAvpid(const string);
  string getAccid();
  void setAccid(const string);
  string getAddid();
  void setAddid(const string);
  string getBilid();
  void setBilid(const string);
  int getBilmodid();
  void setBilmodid(int);
  void avp_add(user_avp);
  int avp_size();
  user_avp avp_get(int);
  void avp_set(int,user_avp);
  void cmd_add(cmd_avp);
  int cmd_size();
  cmd_avp cmd_get(int);
  void acc_add(db_user_acc);
  int acc_size();
  db_user_acc acc_get(int);
  void bilres_add(db_bilres);
  int bilres_size();
  db_bilres bilres_get(int);
  bool getResult();
  void setResult(bool);
  bool getConnect();
  void setConnect(bool);
  string getResultMsg();
  void setResultMsg(const string);
  int getMaxsess();
  void setMaxsess(int);
  void operator =(db_user);
  bool operator ==(db_user);
  bool operator !=(db_user);
};

// network device information
#define DB_NAS_LEN              64
#define DESCRIPTION_LEN         50
#define SNMP_MODULE_LEN         100
#define SNMP_COMMUNITY_LEN      30
#define TACACS_KEY_LEN          50
#define LOGINSTRING_LEN         32
#define PWDSTRING_LEN           32
#define DEV_TYPE_LEN            32

/*
@short network device information
*
class db_device {
        DLoad *dl;                                              // snmp processor module
 public:
        bool result;                                    // request result
        bool connect;                                   // connect to database result
        mystring<200> result_msg;               // request result message

        db_device(ipaddr h) {           // constructor
                dl = 0;
                hostaddr = h;
                community<<"public"<<end();
                descr<<"unknown"<<end();
                module<<"none.so"<<end();
                tac_key<<"none"<<end();
                loginstring<<"login:"<<end();
                pwdstring<<"Password:"<<end();
                dev_type<<"host"<<end();
                trfcounter = false;
                snmppoll = false;
                icmppoll = false;
                delay = 60;                                                             // sec
                shutdown = true;                                        // disabled as default
                def_author = false;                             // no permit default authorization - security!
        }
        ~db_device() {                                                  // destructor
                if(dl) delete dl;
        }
        // information from config
        int delay;                                                                                                                      // polling delay
        string dev_type;                                // device type
        string descr;                           // description
        string community;       // community
        ipaddr hostaddr;                                                                                                // hostname/hostaddr
        string module;                          // snmp module name
        bool trfcounter;                                                                                                // store traffic or not
        bool snmppoll;                                                                                                  // poll or not by snmp
        bool icmppoll;                                                                                                  // poll or not by icmp
        bool shutdown;                                                                                                  // working position or not
        string tac_key;                         // tac+ key
        string loginstring;     // login req str
        string pwdstring;                       // passwd req str
        bool def_author;                                                                                                // default authorization
        // internal information
        bool status;                                                                                                            // last status (on/off)
        int rest;                                                                                                                               // polling delay rest
        char *load() {                                                                                                  // load module
                static char out[80];
                if(dl) delete dl;
                dl = new DLoad;
                mystring<400> str;
//std::cout<<"try to load module "<<module.get()<<std::endl;
                str<<dl->snmpload(module.get())<<end();
                if(strlen(str.c_str())>0) {
                        //TLOG(LOG_ERROR,"snmp module: %s",str.c_str());
                        // error in load module
                        getnas = 0;
                        dropnas = 0;
                        return str.c_str();
                }
                getnas = (bool (*)(SnmpDevice*,snmp_d*(*)(char*,char*,char*),char*))
                                dl->getfunc("getnas");
                dropnas = (bool (*)(SnmpDevice*,char*,snmp_d*(*)(char*,char*,char*),
                                                bool (*)(char*,char*,char*,char*,char),char*))
                                                        dl->getfunc("dropnas");
                if(getnas == 0 || dropnas == 0) {
                        str<<"Unknown snmp module "<<module.get()<<" format"<<end();
                        return str.get();
                }
                return "";
        }
        // dynamically loaded functions for snmp processing
        bool (*getnas)(SnmpDevice*,snmp_d*(*)(char*,char*,char*),char*);
        bool (*dropnas)(SnmpDevice*,char*,
                snmp_d*(*)(char*,char*,char*),
                    bool(*)(char*,char*,char*,char*,char),char*);
        void operator =(db_device a) {
                delay = a.delay;
                dev_type = a.dev_type;
                descr = a.descr;
                community = a.community;
                hostaddr = a.hostaddr;
                module = a.module;
                trfcounter = a.trfcounter;
                snmppoll = a.snmppoll;
                icmppoll = a.icmppoll;
                shutdown = a.shutdown;
                tac_key = a.tac_key;
                loginstring = a.loginstring;
                pwdstring = a.pwdstring;
                def_author = a.def_author;
                status = a.status;
                rest = a.rest;
                // we do not load module here - do it manually
        }
};
*/

#define DB_H323_ORIGIN_LEN  15
#define DB_H323_TYPE_LEN    15

class log_user {
 public:
  int action;
  ipaddr server;
  int task_id;
  time_t servtime;
  time_t start_time;
  string username;
  string from;
  string port;
  unsigned int elapsed;
  ipaddr ip;
  ipaddr nas;
  string service;
  string protocol;
  int disc_cause;
  int disc_cause_ext;
  unsigned int bytes_in;
  unsigned int bytes_out;
  unsigned int rx_speed;
  unsigned int tx_speed;
  // VoIP parameters
  string h323_call_origin;
  string h323_call_type;
  int h323_disconnect_cause;
  int h323_voice_quality;
  ipaddr h323_remote_address;
  time_t h323_connect_time;
  time_t h323_disconnect_time;
  log_user() {
    server = UNKNOWN_IP;
    nas = UNKNOWN_IP;
    ip = UNKNOWN_IP;
    action = 0;
    servtime   = 0;
    start_time = 0;
    elapsed = 0;
    disc_cause = 0;
    disc_cause_ext = 0;
    bytes_in   = 0;
    bytes_out  = 0;
    rx_speed   = 0;
    tx_speed   = 0;
    task_id    = 0;
    h323_connect_time = 0;
    h323_disconnect_time = 0;
    h323_disconnect_cause = 0;
    h323_voice_quality = 0;
  }
  ~log_user() {}
};

class DbList {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  list<DbTable*> dt_;
 public:
  void add(const string,const string,const string);
  DbTable *get(const string);
  DbTable *get(int);
  DbList();
  ~DbList();
  int size();
};

//class DbModule : public md5 {
class DbModule {
  pthread_mutex_t mutex_;
  void lock();
  void unlock();
  //int cid_;
  string dbname_;
  ipaddr location_;
  unsigned int dbport_;
  string cryptokey_;
  string username_;
  string password_;
  string module_;
  bool shutdown_;
 public:
  void setLocation(ipaddr);
  ipaddr getLocation();
  void setDbname(string);
  string getDbname();
  void setDbport(unsigned int);
  unsigned int getDbport();
  void setCryptokey(string);
  string getCryptokey();
  void setUsername(const string);
  string getUsername();
  void setPassword(const string);
  string getPassword();
  void setModule(const string);
  string getModule();
  void setShutdown(bool);
  bool getShutdown();
  void setdbid(const char*,const char*,int);
  string getdbid();
  string encrypt(char*,char*);
  string decrypt(char*,char*);
  void create_md5_hash(unsigned char*, unsigned char*);
  void md5_xor(unsigned char*,unsigned char*);

  // pointers to functions for dynamic loading

  void (*dl_init)();
  void (*dl_destroy)();
  int (*dl_open)(char*,int,char*,char*,char*,char*);
  bool (*dl_close)(int);
  bool (*dl_query)(int,DbTable*,char*);
  char* (*dl_function)(int,char*,char*);
  bool (*dl_get)(int,DbTable*,int,char*);
  bool (*dl_create)(int,DbTable*,char*);
  bool (*dl_create_idx)(int,DbTable*,char*);
  bool (*dl_add)(int,DbTable*,char*);
  bool (*dl_update)(int,DbTable*,char*);
  bool (*dl_del)(int,DbTable*,char*);
  DbModule(const char*,const char*,const char*,int,const char*,const char*,const char*);
  bool db_open(int*);
  bool db_close(int);
  bool db_query(int,DbTable*);
  string db_function(int,char*);
  bool db_get(int,DbTable*,int);
  bool db_create(int,DbTable*,char*);
  bool db_create_idx(int,DbTable*,char*);
  bool db_add(int,DbTable*);
  bool db_update(int,DbTable*);
  bool db_del(int,DbTable*);
  ~DbModule();
};

class TacDb : public DbModule {
  pthread_mutex_t Mutex_;
  void lock();
  void unlock();
  ipaddr our_ip_;
 public:
  DLoad *dl;
  TacDb(const char*,const char*,const char*,int,const char*,const char*,const char*);
  ~TacDb();
  db_user get(const string);
  int size();
  string direct_function_query(char*);
  string load();
  string create();

  // universal manipulation functions
  string del(string,list<string>,list<string>);
  string show(string,list<string>,list<string>);
  list<string> sshow(string,list<string>,list<string>);
  string add(string,list<string>,list<string>);
  string modify(string,list<string>,list<string>,list<string>,list<string>);
  string add_log(log_user*);
  string add_trf(char*,SnmpOut*);
  int open_nf();
  void close_nf(int);
  string add_nf(int,Bit32,Bit32,Bit32,time_t,time_t,unsigned long,unsigned long,int);//NfData*);
  string get_table_name(int);
  string get_table_mask(int);
  string get_table_descr(int);
  string get_field_name(int,int);
  string get_field_descr(int,int);
  string get_field_defv(int,int);
  int get_field_type(int,int);
  int get_field_num(int);
};

};

#endif //__TACDB_H__

---