src/modules/m_xline_db.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
   5  *   Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net>
   6  *
   7  * This file is part of InspIRCd.  InspIRCd is free software: you can
   8  * redistribute it and/or modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation, version 2.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include "inspircd.h"
  22 #include "xline.h"
  23
  24 /* $ModConfig: <xlinedb filename="data/xline.db">
  25  *  Specify the filename for the xline database here*/
  26 /* $ModDesc: Keeps a dynamic log of all XLines created, and stores them in a seperate conf file (xline.db). */
  27
  28 class ModuleXLineDB : public Module
  29 {
  30         bool dirty;
  31         std::string xlinedbpath;
  32  public:
  33         void init()
  34         {
  35                 /* Load the configuration
  36                  * Note:
  37                  *              this is on purpose not in the OnRehash() method. It would be non-trivial to change the database on-the-fly.
  38                  *              Imagine a scenario where the new file already exists. Merging the current XLines with the existing database is likely a bad idea
  39                  *              ...and so is discarding all current in-memory XLines for the ones in the database.
  40                  */
  41                 ConfigTag* Conf = ServerInstance->Config->ConfValue("xlinedb");
  42                 xlinedbpath = Conf->getString("filename", DATA_PATH "/xline.db");
  43
  44                 // Read xlines before attaching to events
  45                 ReadDatabase();
  46
  47                 Implementation eventlist[] = { I_OnAddLine, I_OnDelLine, I_OnExpireLine, I_OnBackgroundTimer };
  48                 ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
  49                 dirty = false;
  50         }
  51
  52         virtual ~ModuleXLineDB()
  53         {
  54         }
  55
  56         /** Called whenever an xline is added by a local user.
  57          * This method is triggered after the line is added.
  58          * @param source The sender of the line or NULL for local server
  59          * @param line The xline being added
  60          */
  61         void OnAddLine(User* source, XLine* line)
  62         {
  63                 dirty = true;
  64         }
  65
  66         /** Called whenever an xline is deleted.
  67          * This method is triggered after the line is deleted.
  68          * @param source The user removing the line or NULL for local server
  69          * @param line the line being deleted
  70          */
  71         void OnDelLine(User* source, XLine* line)
  72         {
  73                 dirty = true;
  74         }
  75
  76         void OnExpireLine(XLine *line)
  77         {
  78                 dirty = true;
  79         }
  80
  81         void OnBackgroundTimer(time_t now)
  82         {
  83                 if (dirty)
  84                 {
  85                         if (WriteDatabase())
  86                                 dirty = false;
  87                 }
  88         }
  89
  90         bool WriteDatabase()
  91         {
  92                 FILE *f;
  93
  94                 /*
  95                  * We need to perform an atomic write so as not to fuck things up.
  96                  * So, let's write to a temporary file, flush and sync the FD, then rename the file..
  97                  * Technically, that means that this can block, but I have *never* seen that.
  98                  *              -- w00t
  99                  */
 100                 ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Opening temporary database");
 101                 std::string xlinenewdbpath = xlinedbpath + ".new";
 102                 f = fopen(xlinenewdbpath.c_str(), "w");
 103                 if (!f)
 104                 {
 105                         ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Cannot create database! %s (%d)", strerror(errno), errno);
 106                         ServerInstance->SNO->WriteToSnoMask('a', "database: cannot create new db: %s (%d)", strerror(errno), errno);
 107                         return false;
 108                 }
 109
 110                 ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Opened. Writing..");
 111
 112                 /*
 113                  * Now, much as I hate writing semi-unportable formats, additional
 114                  * xline types may not have a conf tag, so let's just write them.
 115                  * In addition, let's use a file version, so we can maintain some
 116                  * semblance of backwards compatibility for reading on startup..
 117                  *              -- w00t
 118                  */
 119                 fprintf(f, "VERSION 1\n");
 120
 121                 // Now, let's write.
 122                 std::vector<std::string> types = ServerInstance->XLines->GetAllTypes();
 123                 for (std::vector<std::string>::const_iterator it = types.begin(); it != types.end(); ++it)
 124                 {
 125                         XLineLookup* lookup = ServerInstance->XLines->GetAll(*it);
 126                         if (!lookup)
 127                                 continue; // Not possible as we just obtained the list from XLineManager
 128
 129                         for (LookupIter i = lookup->begin(); i != lookup->end(); ++i)
 130                         {
 131                                 XLine* line = i->second;
 132                                 fprintf(f, "LINE %s %s %s %lu %lu :%s\n", line->type.c_str(), line->Displayable(),
 133                                         ServerInstance->Config->ServerName.c_str(), (unsigned long)line->set_time, (unsigned long)line->duration, line->reason.c_str());
 134                         }
 135                 }
 136
 137                 ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Finished writing XLines. Checking for error..");
 138
 139                 int write_error = 0;
 140                 write_error = ferror(f);
 141                 write_error |= fclose(f);
 142                 if (write_error)
 143                 {
 144                         ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Cannot write to new database! %s (%d)", strerror(errno), errno);
 145                         ServerInstance->SNO->WriteToSnoMask('a', "database: cannot write to new db: %s (%d)", strerror(errno), errno);
 146                         return false;
 147                 }
 148
 149 #ifdef _WIN32
 150                 remove(xlinedbpath.c_str());
 151 #endif
 152                 // Use rename to move temporary to new db - this is guarenteed not to fuck up, even in case of a crash.
 153                 if (rename(xlinenewdbpath.c_str(), xlinedbpath.c_str()) < 0)
 154                 {
 155                         ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Cannot move new to old database! %s (%d)", strerror(errno), errno);
 156                         ServerInstance->SNO->WriteToSnoMask('a', "database: cannot replace old with new db: %s (%d)", strerror(errno), errno);
 157                         return false;
 158                 }
 159
 160                 return true;
 161         }
 162
 163         bool ReadDatabase()
 164         {
 165                 FILE *f;
 166                 char linebuf[MAXBUF];
 167
 168                 f = fopen(xlinedbpath.c_str(), "r");
 169                 if (!f)
 170                 {
 171                         if (errno == ENOENT)
 172                         {
 173                                 /* xline.db doesn't exist, fake good return value (we don't care about this) */
 174                                 return true;
 175                         }
 176                         else
 177                         {
 178                                 /* this might be slightly more problematic. */
 179                                 ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Cannot read database! %s (%d)", strerror(errno), errno);
 180                                 ServerInstance->SNO->WriteToSnoMask('a', "database: cannot read db: %s (%d)", strerror(errno), errno);
 181                                 return false;
 182                         }
 183                 }
 184
 185                 while (fgets(linebuf, MAXBUF, f))
 186                 {
 187                         char *c = linebuf;
 188
 189                         while (c && *c)
 190                         {
 191                                 if (*c == '\n')
 192                                 {
 193                                         *c = '\0';
 194                                 }
 195
 196                                 c++;
 197                         }
 198
 199                         // Inspired by the command parser. :)
 200                         irc::tokenstream tokens(linebuf);
 201                         int items = 0;
 202                         std::string command_p[7];
 203                         std::string tmp;
 204
 205                         while (tokens.GetToken(tmp) && (items < 7))
 206                         {
 207                                 command_p[items] = tmp;
 208                                 items++;
 209                         }
 210
 211                         ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Processing %s", linebuf);
 212
 213                         if (command_p[0] == "VERSION")
 214                         {
 215                                 if (command_p[1] == "1")
 216                                 {
 217                                         ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: Reading db version %s", command_p[1].c_str());
 218                                 }
 219                                 else
 220                                 {
 221                                         fclose(f);
 222                                         ServerInstance->Logs->Log("m_xline_db",DEBUG, "xlinedb: I got database version %s - I don't understand it", command_p[1].c_str());
 223                                         ServerInstance->SNO->WriteToSnoMask('a', "database: I got a database version (%s) I don't understand", command_p[1].c_str());
 224                                         return false;
 225                                 }
 226                         }
 227                         else if (command_p[0] == "LINE")
 228                         {
 229                                 // Mercilessly stolen from spanningtree
 230                                 XLineFactory* xlf = ServerInstance->XLines->GetFactory(command_p[1]);
 231
 232                                 if (!xlf)
 233                                 {
 234                                         ServerInstance->SNO->WriteToSnoMask('a', "database: Unknown line type (%s).", command_p[1].c_str());
 235                                         continue;
 236                                 }
 237
 238                                 XLine* xl = xlf->Generate(ServerInstance->Time(), atoi(command_p[5].c_str()), command_p[3], command_p[6], command_p[2]);
 239                                 xl->SetCreateTime(atoi(command_p[4].c_str()));
 240
 241                                 if (ServerInstance->XLines->AddLine(xl, NULL))
 242                                 {
 243                                         ServerInstance->SNO->WriteToSnoMask('x', "database: Added a line of type %s", command_p[1].c_str());
 244                                 }
 245                                 else
 246                                         delete xl;
 247                         }
 248                 }
 249
 250                 fclose(f);
 251                 return true;
 252         }
 253
 254
 255
 256         virtual Version GetVersion()
 257         {
 258                 return Version("Keeps a dynamic log of all XLines created, and stores them in a separate conf file (xline.db).", VF_VENDOR);
 259         }
 260 };
 261
 262 MODULE_INIT(ModuleXLineDB)
 263