src/modules/extra/m_sqllog.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2004 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 using namespace std;
  18
  19 #include <stdio.h>
  20 #include <string>
  21 #include <stdlib.h>
  22 #include <time.h>
  23 #include <sys/types.h>
  24 #include <sys/socket.h>
  25 #include <sys/time.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <poll.h>
  31 #include "users.h"
  32 #include "channels.h"
  33 #include "modules.h"
  34 #include "inspircd.h"
  35 #include "m_sql.h"
  36
  37 enum LogTypes { LT_OPER = 1, LT_KILL, LT_SERVLINK, LT_XLINE, LT_CONNECT, LT_DISCONNECT, LT_FLOOD, LT_LOADMODULE };
  38
  39 /* $ModDesc: Logs network-wide data to an SQL database */
  40
  41 class ModuleSQLLog : public Module
  42 {
  43         Server* Srv;
  44         ConfigReader* Conf;
  45         unsigned long dbid;
  46         Module* SQLModule;
  47
  48  public:
  49         bool ReadConfig()
  50         {
  51                 Conf = new ConfigReader();
  52                 dbid = Conf->ReadInteger("sqllog","dbid",0,true);       // database id of a database configured in m_sql (see m_sql config)
  53                 delete Conf;
  54                 SQLModule = Srv->FindModule("m_sql.so");
  55                 if (!SQLModule)
  56                         Srv->Log(DEFAULT,"WARNING: m_SQLLog.so could not initialize because m_sql.so is not loaded. Load the module and rehash your server.");
  57                 return (SQLModule);
  58         }
  59
  60         ModuleSQLLog(Server* Me)
  61                 : Module::Module(Me)
  62         {
  63                 Srv = Me;
  64                 ReadConfig();
  65         }
  66
  67         void Implements(char* List)
  68         {
  69                 List[I_OnRehash] = List[I_OnOper] = List[I_OnGlobalOper] = List[I_OnKill] = 1;
  70                 List[I_OnPreCommand] = List[I_OnUserConnect] = List[I_OnGlobalConnect] = 1;
  71                 List[I_OnUserQuit] = List[I_OnLoadModule] = 1;
  72         }
  73
  74         virtual void OnRehash(const std::string &parameter)
  75         {
  76                 ReadConfig();
  77         }
  78
  79         long InsertNick(const std::string &nick)
  80         {
  81                 long nid = -1;
  82                 SQLRequest* query = new SQLRequest(SQL_RESULT,dbid,"SELECT id,actor FROM ircd_log_actors WHERE actor='"+nick+"'");
  83                 Request queryrequest((char*)query, this, SQLModule);
  84                 SQLResult* result = (SQLResult*)queryrequest.Send();
  85                 if (result->GetType() == SQL_OK)
  86                 {
  87                         SQLRequest* rowrequest = new SQLRequest(SQL_ROW,dbid,"");
  88                         Request rowquery((char*)rowrequest, this, SQLModule);
  89                         SQLResult* rowresult = (SQLResult*)rowquery.Send();
  90                         if (rowresult->GetType() == SQL_ROW)
  91                         {
  92                                 nid = atoi(rowresult->GetField("id").c_str());
  93                                 delete rowresult;
  94                         }
  95                         delete rowrequest;
  96                         delete result;
  97                 }
  98                 query->SetQueryType(SQL_DONE);
  99                 query->SetConnID(dbid);
 100                 Request donerequest((char*)query, this, SQLModule);
 101                 donerequest.Send();
 102                 delete query;
 103                 if (nid < 1)
 104                 {
 105                         SQLRequest* query2 = new SQLRequest(SQL_COUNT,dbid,"INSERT INTO ircd_log_actors VALUES('','"+nick+"')");
 106                         Request queryrequest2((char*)query2, this, SQLModule);
 107                         SQLResult* result2 = (SQLResult*)queryrequest2.Send();
 108                         if (result2->GetType() == SQL_ERROR)
 109                         {
 110                                 Srv->Log(DEFAULT,"SQL log error: " + result2->GetError());
 111                         }
 112                         if (result2)
 113                                 delete result;
 114                         if (query2)
 115                                 delete query2;
 116                         nid = InsertNick(nick);
 117                 }
 118                 return nid;
 119         }
 120
 121         void InsertEntry(unsigned long category,unsigned long nickid,unsigned long hostid,unsigned long sourceid,unsigned long date)
 122         {
 123                 char querybuffer[MAXBUF];
 124                 snprintf(querybuffer,MAXBUF,"INSERT INTO ircd_log VALUES('',%lu,%lu,%lu,%lu,%lu)",(unsigned long)category,(unsigned long)nickid,(unsigned long)hostid,(unsigned long)sourceid,(unsigned long)date);
 125                 SQLRequest* query = new SQLRequest(SQL_COUNT,dbid,querybuffer);
 126                 Request queryrequest((char*)query, this, SQLModule);
 127                 SQLResult* result = (SQLResult*)queryrequest.Send();
 128                 if (result->GetType() == SQL_ERROR)
 129                 {
 130                         Srv->Log(DEFAULT,"SQL log error: " + result->GetError());
 131                 }
 132                 if (result)
 133                         delete result;
 134                 if (query)
 135                         delete query;
 136                 return;
 137         }
 138
 139         long InsertHost(const std::string &host)
 140         {
 141                 long hid = -1;
 142                 SQLRequest* query = new SQLRequest(SQL_RESULT,dbid,"SELECT id,hostname FROM ircd_log_hosts WHERE hostname='"+host+"'");
 143                 Request queryrequest((char*)query, this, SQLModule);
 144                 SQLResult* result = (SQLResult*)queryrequest.Send();
 145                 if (result->GetType() == SQL_OK)
 146                 {
 147                         SQLRequest* rowrequest = new SQLRequest(SQL_ROW,dbid,"");
 148                         Request rowquery((char*)rowrequest, this, SQLModule);
 149                         SQLResult* rowresult = (SQLResult*)rowquery.Send();
 150                         if (rowresult->GetType() == SQL_ROW)
 151                         {
 152                                 hid = atoi(rowresult->GetField("id").c_str());
 153                                 delete rowresult;
 154                         }
 155                         delete rowrequest;
 156                         delete result;
 157                 }
 158                 query->SetQueryType(SQL_DONE);
 159                 query->SetConnID(dbid);
 160                 Request donerequest((char*)query, this, SQLModule);
 161                 donerequest.Send();
 162                 delete query;
 163                 if (hid < 1)
 164                 {
 165                         SQLRequest* query2 = new SQLRequest(SQL_COUNT,dbid,"INSERT INTO ircd_log_hosts VALUES('','"+host+"')");
 166                         Request queryrequest2((char*)query2, this, SQLModule);
 167                         SQLResult* result2 = (SQLResult*)queryrequest2.Send();
 168                         if (result2->GetType() == SQL_ERROR)
 169                         {
 170                                 Srv->Log(DEFAULT,"SQL log error: " + result2->GetError());
 171                         }
 172                         if (result)
 173                                 delete result2;
 174                         if (query)
 175                                 delete query2;
 176                         hid = InsertHost(host);
 177                 }
 178                 return hid;
 179         }
 180
 181         void AddLogEntry(int category, const std::string &nick, const std::string &host, const std::string &source)
 182         {
 183                 // is the sql module loaded? If not, we don't attempt to do anything.
 184                 if (!SQLModule)
 185                         return;
 186
 187                 long nickid = InsertNick(nick);
 188                 long sourceid = InsertNick(source);
 189                 long hostid = InsertHost(host);
 190                 InsertEntry((unsigned)category,(unsigned)nickid,(unsigned)hostid,(unsigned)sourceid,(unsigned long)time(NULL));
 191         }
 192
 193         virtual void OnOper(userrec* user, const std::string &opertype)
 194         {
 195                 AddLogEntry(LT_OPER,user->nick,user->host,user->server);
 196         }
 197
 198         virtual void OnGlobalOper(userrec* user)
 199         {
 200                 AddLogEntry(LT_OPER,user->nick,user->host,user->server);
 201         }
 202
 203         virtual int OnKill(userrec* source, userrec* dest, const std::string &reason)
 204         {
 205                 AddLogEntry(LT_KILL,dest->nick,dest->host,source->nick);
 206                 return 0;
 207         }
 208
 209         virtual int OnPreCommand(const std::string &command, char **parameters, int pcnt, userrec *user, bool validated)
 210         {
 211                 if ((command == "GLINE") || (command == "KLINE") || (command == "ELINE") || (command == "ZLINE"))
 212                 {
 213                         AddLogEntry(LT_XLINE,user->nick,command[0]+std::string(":")+std::string(parameters[0]),user->server);
 214                 }
 215                 return 0;
 216         }
 217
 218         virtual void OnUserConnect(userrec* user)
 219         {
 220                 AddLogEntry(LT_CONNECT,user->nick,user->host,user->server);
 221         }
 222
 223         virtual void OnGlobalConnect(userrec* user)
 224         {
 225                 AddLogEntry(LT_CONNECT,user->nick,user->host,user->server);
 226         }
 227
 228         virtual void OnUserQuit(userrec* user, const std::string &reason)
 229         {
 230                 AddLogEntry(LT_DISCONNECT,user->nick,user->host,user->server);
 231         }
 232
 233         virtual void OnLoadModule(Module* mod, const std::string &name)
 234         {
 235                 AddLogEntry(LT_LOADMODULE,name,Srv->GetServerName(),Srv->GetServerName());
 236         }
 237
 238         virtual ~ModuleSQLLog()
 239         {
 240         }
 241
 242         virtual Version GetVersion()
 243         {
 244                 return Version(1,0,0,1,VF_VENDOR);
 245         }
 246
 247 };
 248
 249 class ModuleSQLLogFactory : public ModuleFactory
 250 {
 251  public:
 252         ModuleSQLLogFactory()
 253         {
 254         }
 255
 256         ~ModuleSQLLogFactory()
 257         {
 258         }
 259
 260         virtual Module * CreateModule(Server* Me)
 261         {
 262                 return new ModuleSQLLog(Me);
 263         }
 264
 265 };
 266
 267
 268 extern "C" void * init_module( void )
 269 {
 270         return new ModuleSQLLogFactory;
 271 }
 272