source/Bot.C

   1 // Bot.C  -*- C++ -*-
   2 // Copyright (c) 1997, 1998 Etienne BERNARD
   3 // Copyright (C) 2002 Clinton Ebadi
   4
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  18
  19 #include <fstream>
  20 #include <algorithm>
  21 #include <iomanip>
  22 #include <cstring>
  23 #include <cstdlib>
  24 #include <cstdio>
  25 #include <sys/time.h>
  26 #include <sys/types.h>
  27 #include <unistd.h>
  28
  29 #include "Bot.H"
  30 #include "DCCConnection.H"
  31 #include "StringTokenizer.H"
  32 #include "ServerConnection.H"
  33 #include "Utils.H"
  34 #include "UserCommands.H"
  35 #include "DCCManager.H"
  36
  37 #define DEFAULT_NICKNAME "Bobot"
  38 #define DEFAULT_USERNAME "bobot"
  39 #define DEFAULT_IRCNAME "I'm a bobot++!"
  40 #define DEFAULT_COMMANDCHAR '!'
  41 #define DEFAULT_USERLISTFILENAME "bot.users"
  42 #define DEFAULT_SHITLISTFILENAME "bot.shit"
  43 #define DEFAULT_HELPFILENAME "bot.help"
  44 #define DEFAULT_SCRIPTLOGFILENAME "script.log"
  45 #define DEFAULT_LOGFILENAME "bot.log"
  46 #define DEFAULT_LOGDIR getenv ("HOME") + String("/.bobotpp/logs/")
  47 #define DEFAULT_INITFILENAME "bot.init"
  48 #ifdef USESCRIPTS
  49 #define DEFAULT_AUTOEXECFILENAME "bot.autoexec"
  50 #endif
  51
  52 Bot::Bot(String filename, bool debug_on)
  53   : nickName(DEFAULT_NICKNAME),
  54     wantedNickName(DEFAULT_NICKNAME),
  55     userName(DEFAULT_USERNAME),
  56     ircName(DEFAULT_IRCNAME),
  57     versionString(VERSION_STRING),
  58     userHost(""),
  59     localIP(""),
  60     commandChar(DEFAULT_COMMANDCHAR),
  61     configFileName(filename),
  62     userListFileName(DEFAULT_USERLISTFILENAME),
  63     shitListFileName(DEFAULT_SHITLISTFILENAME),
  64     logFileName(DEFAULT_LOGFILENAME),
  65     logs_dir (DEFAULT_LOGDIR),
  66     helpFileName(DEFAULT_HELPFILENAME),
  67     initFileName(DEFAULT_INITFILENAME),
  68 #ifdef USESCRIPTS
  69     scriptLogFileName(DEFAULT_SCRIPTLOGFILENAME),
  70     autoexecFileName(DEFAULT_AUTOEXECFILENAME),
  71 #endif
  72     connected(false),
  73     debug(debug_on), stop(false), sentPing(false),
  74     startTime(time(NULL)), currentTime(startTime),
  75     lastNickNameChange(startTime), lastChannelJoin(startTime),
  76     serverConnection(0), sentUserhostID(0), receivedUserhostID(0)
  77 {
  78 #ifdef HAVE_STL_CLEAR
  79   wantedChannels.clear();
  80   ignoredUserhosts.clear();
  81   spyList.clear();
  82   userhostMap.clear();
  83 #endif
  84
  85   init_user_functions ();
  86
  87   set_log_dir (logs_dir);
  88   set_log_file (logFileName);
  89
  90
  91   channelList = new ChannelList();
  92   serverList = new ServerList();
  93   readConfig();
  94   userList = new UserList(userListFileName);
  95   shitList = new ShitList(shitListFileName);
  96   todoList = new TodoList();
  97   dccConnections = new DCCManager ();
  98
  99   // Let's read the alias file
 100   std::ifstream initFile(initFileName);
 101
 102   if (initFile) {
 103     String temp, alias, command;
 104     int line = 0;
 105     while (initFile >> temp, temp.length() != 0) {
 106       line++;
 107       StringTokenizer st(temp);
 108       temp = temp.trim();
 109       if (temp[0]=='#') continue;
 110       if (st.countTokens(' ') != 2) {
 111         std::cerr << "Error when reading alias file (" << initFileName
 112                   << ") line " << line << "...\n";
 113         continue;
 114       }
 115       alias = st.nextToken().toUpper();
 116       command = st.nextToken().toUpper();
 117
 118       // Does the function already exist ?
 119       if (!userFunctions[alias])
 120         {
 121           if (userFunction *u = userFunctions[command])
 122             userFunctions[alias] =
 123               new
 124               userFunction(u->function,
 125                            u->minLevel,
 126                            u->needsChannelName);
 127         }
 128     }
 129   }
 130
 131
 132   std::srand (std::time (0)); // srand for bot-random
 133 #ifdef USESCRIPTS
 134   botInterp = new BotInterp(this, logs_dir + scriptLogFileName);
 135   botInterp->LoadScript(autoexecFileName);
 136 #endif
 137 }
 138
 139 Bot::~Bot()
 140 {
 141   Person *p;
 142   while (spyList.size() != 0) {
 143     p = (*spyList.begin()).second;
 144     spyList.erase(spyList.begin());
 145     delete p;
 146   }
 147   delete dccConnections;
 148   destroy_user_functions ();
 149
 150   wantedChannel *w;
 151   while (wantedChannels.size() != 0) {
 152     w = (*wantedChannels.begin()).second;
 153     wantedChannels.erase(wantedChannels.begin());
 154     delete w;
 155   }
 156   userList->save();
 157   shitList->save();
 158   delete channelList;
 159   delete userList;
 160   delete todoList;
 161   delete serverList;
 162   delete shitList;
 163   delete serverConnection;
 164   logLine("Stopping log.");
 165   logFile.close();
 166 }
 167
 168 void
 169 Bot::logLine(String line)
 170 {
 171   tm *d;
 172   std::time_t current_time = time(0);
 173
 174   d = localtime(&current_time);
 175   logFile << "[" <<  std::setfill('0') << std::setw(2)
 176           << d->tm_mday << "/" <<  std::setfill('0') << std::setw(2)
 177           << d->tm_mon + 1 << "/"
 178           << d->tm_year + 1900 << " - " <<  std::setfill('0') << std::setw(2)
 179           << d->tm_hour << ":" <<  std::setfill('0') << std::setw(2)
 180           << d->tm_min << ":" <<  std::setfill('0') << std::setw(2)
 181           << d->tm_sec << "] "
 182           << line
 183           << std::endl;
 184 }
 185
 186 void
 187 Bot::readConfig()
 188 {
 189   std::ifstream file(configFileName);
 190   String temp;
 191   int line = 1;
 192
 193   if (!file) {
 194     logLine(String("I cannot find the file ") + configFileName);
 195     return;
 196   }
 197
 198   while (!file.eof()) {
 199
 200     file >> temp;
 201
 202     if (temp.length() == 0 || temp[0] == '#') {
 203       line++;
 204       continue;
 205     }
 206
 207     StringTokenizer st(temp);
 208     String command = st.nextToken('=').trim().toUpper();
 209     String parameters = st.nextToken('=').trim();
 210
 211     if (command == "NICK" || command == "NICKNAME")
 212       nickName = wantedNickName = parameters;
 213     else if (command == "USERNAME")
 214       userName = parameters;
 215     else if (command == "IRCNAME" || command == "REALNAME")
 216       ircName = parameters;
 217     else if (command == "CMDCHAR" || command == "COMMAND")
 218       commandChar = parameters[0];
 219     else if (command == "USERLIST")
 220       userListFileName = parameters;
 221     else if (command == "SHITLIST")
 222       shitListFileName = parameters;
 223     else if (command == "CHANNEL") {
 224       if (parameters.indexOf(':') == -1) {
 225         std::cout << "Warning. The 'channel' syntax has changed."
 226                   << " Please see the README file for more information."
 227                   << " I will use compatibility mode, but you're really"
 228                   << " missing something.\n";
 229         StringTokenizer st2(parameters);
 230         String name = st2.nextToken().toLower();
 231         String key = st2.nextToken();
 232         wantedChannels[name] = new wantedChannel("", "", key);
 233       } else {
 234         StringTokenizer st2(parameters);
 235         String name = st2.nextToken(':').toLower();
 236         String mode = st2.nextToken(':');
 237         String keep = st2.nextToken(':');
 238         String key = st2.nextToken(':');
 239         wantedChannels[name] = new wantedChannel(mode, keep, key);
 240       }
 241     }
 242     else if (command == "LOGFILE")
 243       {
 244         if (parameters != logFileName)
 245           {
 246             if (parameters[0] == '/')
 247               {
 248                 set_log_dir ("/");
 249                 set_log_file (parameters.subString (1));
 250               }
 251             else
 252               set_log_file (parameters);
 253           }
 254       }
 255 #ifdef USESCRIPTS
 256     else if (command == "SCRIPTLOGFILE")
 257       scriptLogFileName = parameters;
 258     else if (command == "AUTOEXECFILE")
 259       autoexecFileName = parameters;
 260 #endif
 261     else if (command == "INITFILE")
 262       initFileName = parameters;
 263     else if (command == "LOCALIP")
 264       localIP = parameters;
 265     else if (command == "SERVER") {
 266       if (parameters.indexOf(' ') == -1)
 267         serverList->addServer(new Server(parameters));
 268       else {
 269         StringTokenizer st2(parameters);
 270         String name = st2.nextToken();
 271         int port = std::atoi(st2.nextToken());
 272         serverList->addServer(new Server(name,
 273                                          port,
 274                                          st2.nextToken()));
 275       }
 276     }
 277     else {
 278       logLine(String("Syntax error in file ") + configFileName +
 279               ", line " + String((long)line));
 280       file.close();
 281       std::exit(1);
 282     }
 283
 284     line++;
 285   }
 286
 287   file.close();
 288 }
 289
 290 void
 291 Bot::run()
 292 {
 293   nextServer();
 294
 295   while (!stop) {
 296     waitForInput();  // This is the main event loop
 297     dccConnections->checkStale ();
 298     if (!serverConnection->queue->flush())
 299       nextServer();
 300   }
 301 }
 302
 303 void
 304 Bot::waitForInput()
 305 {
 306 #ifdef _HPUX_SOURCE
 307   int rd;
 308 #else
 309   fd_set rd;
 310 #endif
 311   struct timeval timer;
 312
 313   int sock = serverConnection->getFileDescriptor();
 314   int maxSocketNumber = sock;
 315
 316 #ifdef _HPUX_SOURCE
 317   rd = sock;
 318 #else
 319   FD_ZERO(&rd);
 320   FD_SET(sock, &rd);
 321 #endif
 322
 323   DCC_MAP* dccmap = &dccConnections->dcc_map;
 324   for (DCC_MAP::iterator it = dccmap->begin ();
 325        it != dccmap->end(); ++it) {
 326     int s = it->second->dcc->getFileDescriptor();
 327 #ifdef _HPUX_SOURCE
 328     rd |= s;
 329 #else
 330     FD_SET(s, &rd);
 331 #endif
 332     if (s > maxSocketNumber)
 333       maxSocketNumber = s;
 334   }
 335
 336   timer.tv_sec = 1;
 337   timer.tv_usec = 0;
 338
 339   switch (select(maxSocketNumber + 1, &rd, NULL, NULL, &timer)) {
 340   case 0: /* timeout */
 341     break;
 342   case -1: /* error */
 343     break;
 344   default: /* normal */
 345 #ifdef _HPUX_SOURCE
 346     if (rd & sock)
 347 #else
 348     if (FD_ISSET(sock, &rd))
 349 #endif
 350       if (serverConnection->handleInput())
 351         nextServer();
 352
 353 //     std::list<DCCConnection *>::iterator it = dccConnections.begin();
 354 //     std::list<DCCConnection *>::iterator it2;
 355
 356 //     while (it != dccConnections.end()) {
 357 //       it2 = it;
 358 //       ++it;
 359 // #ifdef _HPUX_SOURCE
 360 //       if (rd & (*it2)->getFileDescriptor()) {
 361 // #else
 362 //       if (FD_ISSET((*it2)->getFileDescriptor(), &rd)) {
 363 // #endif
 364 //         if ((*it2)->handleInput()) {
 365 //           delete *it2;
 366 //           dccConnections.erase(it2);
 367 //         }
 368 //       }
 369 //     }
 370 //     }
 371     dccConnections->checkInput (rd);
 372   }
 373
 374   if (currentTime < std::time(0)) { // Actions that we do each second
 375     currentTime = std::time(0);
 376     for (std::map<String, unsigned int, std::less<String> >::iterator
 377            it = ignoredUserhosts.begin();
 378          it != ignoredUserhosts.end(); ++it)
 379       if ((*it).second > 0)
 380         (*it).second--;
 381
 382     String line;
 383     while ((line = todoList->getNext()) != "") {
 384       serverConnection->queue->sendChannelMode(line);
 385     }
 386 #ifdef USESCRIPTS
 387     botInterp->RunTimers(currentTime);
 388 #endif
 389
 390 #ifdef USESCRIPTS
 391     tm *thisTime = localtime(&currentTime);
 392     if (thisTime->tm_sec == 0) {
 393       char s[6];
 394       std::sprintf(s, "%2d:%2d", thisTime->tm_hour, thisTime->tm_min);
 395       botInterp->RunHooks(Hook::TIMER, String(s),
 396                           gh_list(Utils::string2SCM(String(s)),
 397                                   SCM_UNDEFINED));
 398     }
 399 #endif
 400
 401   }
 402
 403   if (currentTime >= (time_t)(lastNickNameChange + Bot::NICK_CHANGE) &&
 404       nickName != wantedNickName) {
 405     lastNickNameChange = currentTime;
 406     serverConnection->queue->sendNick(wantedNickName);
 407   }
 408
 409   if (currentTime >= (std::time_t)(lastChannelJoin + Bot::CHANNEL_JOIN)) {
 410     lastChannelJoin = currentTime;
 411     for (std::map<String, wantedChannel *, std::less<String> >::iterator it =
 412            wantedChannels.begin(); it != wantedChannels.end();
 413          ++it)
 414       if (channelList->getChannel((*it).first) == 0)
 415          serverConnection->queue->sendJoin((*it).first, (*it).second->key);
 416   }
 417
 418 //   std::list<DCCConnection *>::iterator it2;
 419
 420 //   for (std::list<DCCConnection *>::iterator it = dccConnections.begin();
 421 //        it != dccConnections.end(); ) {
 422 //     it2 = it;
 423 //     ++it;
 424 //     if ((*it2)->autoRemove && currentTime >= (std::time_t)((*it2)->lastSpoken + Bot::DCC_DELAY)) {
 425 //       delete *it2;
 426 //       dccConnections.erase(it2);
 427 //     }
 428 //   }
 429
 430   if (currentTime >= (std::time_t)(serverConnection->serverLastSpoken + Bot::PING_TIME) && !sentPing) {
 431     serverConnection->queue->sendPing("Testing connection");
 432     sentPing = true;
 433   }
 434
 435   if (currentTime >= (std::time_t)(serverConnection->serverLastSpoken + Bot::TIMEOUT)) {
 436     sentPing = false;
 437     nextServer();
 438   }
 439 }
 440
 441 // We can change server if we will not lose op on a channel
 442 bool
 443 Bot::canChangeServer()
 444 {
 445   String channel;
 446   Channel *c;
 447
 448   for (std::map<String, Channel *, std::less<String> >::iterator it =
 449          channelList->begin();
 450        it != channelList->end(); ++it) {
 451     channel = (*it).first;
 452     c = channelList->getChannel(channel);
 453     if (c->countOp == 1 &&
 454         c->count > 1 && this->iAmOp(channel))
 455       return false;
 456   }
 457   return true;
 458 }
 459
 460 void
 461 Bot::nextServer()
 462 {
 463   bool cont = false;
 464
 465   if (channelList)
 466     channelList->clear();
 467
 468   if (serverConnection)
 469     userList->removeFirst();
 470
 471   delete serverConnection;
 472
 473   do {
 474     Server * s = serverList->nextServer();
 475     if (!s) {
 476       std::cout << "No server found. Exiting..." << std::endl;
 477       std::exit(1);
 478     }
 479     serverConnection = new ServerConnection(this, s, localIP);
 480     if (!serverConnection->connect()) {
 481       cont = true;
 482       // We sleep 10 seconds, to avoid connection flood
 483       sleep(10);
 484       delete serverConnection;
 485     } else {
 486       cont = false;
 487     }
 488   } while (cont);
 489 }
 490
 491 void
 492 Bot::reconnect()
 493 {
 494   if (channelList)
 495     channelList->clear();
 496
 497   userList->removeFirst();
 498
 499   delete serverConnection;
 500
 501   serverConnection =
 502     new ServerConnection(this, serverList->currentServer(), localIP);
 503
 504   serverConnection->connect();
 505 }
 506
 507 void
 508 Bot::connect(int serverNumber)
 509 {
 510   if (channelList)
 511     channelList->clear();
 512
 513   userList->removeFirst();
 514
 515   delete serverConnection;
 516
 517   serverConnection =
 518     new ServerConnection(this, serverList->get(serverNumber), localIP);
 519
 520   serverConnection->connect();
 521 }
 522
 523 void
 524 Bot::addDCC(Person * from, unsigned long address, int port)
 525 {
 526   DCCConnection * d = new DCCConnection(this, from->getAddress (),
 527                                         address, port);
 528
 529   if (!d->connect())
 530     {
 531       logLine ("DCC Connection failed from " + from->getAddress ());
 532       return;
 533     }
 534   logLine ("DCC CHAT accepted from" + from->getAddress ());
 535   dccConnections->addConnection (d);
 536 }
 537
 538 void
 539 Bot::rehash()
 540 {
 541   for (std::map<String, Channel *, std::less<String> >::iterator it =
 542          channelList->begin();
 543        it != channelList->end(); ++it)
 544     serverConnection->queue->sendWho((*it).first);
 545 }
 546
 547 String
 548 Bot::getUserhost(String channel, String nick)
 549 {
 550   Channel *c;
 551
 552   if (channel == "")
 553     c = 0;
 554   else
 555     c = channelList->getChannel(channel);
 556
 557   nick = nick.toLower();
 558
 559
 560   if (c && c->hasNick(nick))
 561     return c->getUser(nick)->userhost;
 562
 563   unsigned long num = sentUserhostID++;
 564
 565   serverConnection->queue->sendUserhost(nick);
 566   userhostMap[num] = "+";
 567
 568   while (userhostMap[num] == "+") {
 569     waitForInput();
 570     serverConnection->queue->flush();
 571   }
 572
 573   // We have got our answer
 574   String res = userhostMap[num];
 575   userhostMap.erase(num);
 576
 577   return res;
 578 }
 579
 580 bool
 581 Bot::iAmOp(String channel)
 582 {
 583   User * me = channelList->getChannel(channel)->getUser(nickName);
 584   return (me->mode & User::OP_MODE);
 585 }
 586
 587 void
 588 Bot::init_user_functions ()
 589 {
 590     // User Functions
 591 #define uf(f, l, b) new userFunction (f, l, b);
 592   userFunctions["ACTION"] = uf (UserCommands::Action, User::USER, true);
 593   userFunctions["ADDUSER"] = uf (UserCommands::AddUser, User::FRIEND, false);
 594   userFunctions["ADDSERVER"] = uf (UserCommands::AddServer, User::FRIEND,
 595                                     false);
 596   userFunctions["ADDSHIT"] = uf (UserCommands::AddShit, User::FRIEND, false);
 597   userFunctions["ALIAS"] = uf (UserCommands::Alias, User::MASTER, false);
 598   userFunctions["BAN"] = uf (UserCommands::Ban, User::USER, true);
 599   userFunctions["BANLIST"] = uf (UserCommands::BanList, User::USER, true);
 600   userFunctions["CHANNELS"] =
 601     uf (UserCommands::Channels, User::FRIEND, false);
 602   userFunctions["CYCLE"] = uf (UserCommands::Cycle, User::FRIEND, true);
 603   userFunctions["DCCLIST"] = uf (UserCommands::DCCList, User::FRIEND, false);
 604   userFunctions["DEBAN"] = uf (UserCommands::Deban, User::USER, true);
 605   userFunctions["DELSERVER"] = uf (UserCommands::DelServer, User::FRIEND,
 606                                     false);
 607   userFunctions["DELUSER"] = uf (UserCommands::DelUser, User::FRIEND, false);
 608   userFunctions["DELSHIT"] = uf (UserCommands::DelShit, User::FRIEND, false);
 609   userFunctions["DEOP"] = uf (UserCommands::Deop, User::TRUSTED_USER, true);
 610   userFunctions["DIE"] = uf (UserCommands::Die, User::MASTER, false);
 611   userFunctions["DO"] = uf (UserCommands::Do, User::MASTER, false);
 612 #ifdef USESCRIPTS
 613   userFunctions["EXECUTE"] = uf (UserCommands::Execute, User::MASTER, false);
 614 #endif
 615   userFunctions["HELP"] = uf (UserCommands::Help, User::NONE, false);
 616   userFunctions["IDENT"] = uf (UserCommands::Ident, User::NONE, true);
 617   userFunctions["INVITE"] = uf (UserCommands::Invite, User::USER, true);
 618   userFunctions["JOIN"] = uf (UserCommands::Join, User::FRIEND, false);
 619   userFunctions["KEEP"] = uf (UserCommands::Keep, User::FRIEND, true);
 620   userFunctions["KICK"] = uf (UserCommands::Kick, User::USER, true);
 621   userFunctions["KICKBAN"] = uf (UserCommands::KickBan, User::USER, true);
 622   userFunctions["LOAD"] = uf (UserCommands::Load, User::FRIEND, false);
 623 #ifdef USESCRIPTS
 624   userFunctions["LOADSCRIPT"] = uf (UserCommands::LoadScript, User::MASTER,
 625                                      false);
 626 #endif
 627   userFunctions["LOCK"] = uf (UserCommands::Lock, User::FRIEND, true);
 628   userFunctions["MODE"] = uf (UserCommands::Mode, User::FRIEND, true);
 629   userFunctions["MSG"] = uf (UserCommands::Msg, User::USER, false);
 630   userFunctions["NAMES"] = uf (UserCommands::Names, User::USER, true);
 631   userFunctions["NEXTSERVER"] = uf (UserCommands::NextServer, User::FRIEND,
 632                                      false);
 633   userFunctions["NICK"] = uf (UserCommands::Nick, User::FRIEND, false);
 634   userFunctions["NSLOOKUP"] = uf (UserCommands::NsLookup, User::USER, false);
 635   userFunctions["OP"] = uf (UserCommands::Op, User::TRUSTED_USER, true);
 636   userFunctions["PART"] = uf (UserCommands::Part, User::FRIEND, true);
 637   userFunctions["PASSWORD"] = uf (UserCommands::Password, User::USER, true);
 638   userFunctions["RECONNECT"] =
 639     uf (UserCommands::Reconnect, User::FRIEND, false);
 640   userFunctions["RSPYMESSAGE"] =
 641     uf (UserCommands::RSpyMessage, User::USER, false);
 642   userFunctions["SAVE"] = uf (UserCommands::Save, User::FRIEND, false);
 643   userFunctions["SAY"] = uf (UserCommands::Say, User::USER, true);
 644   userFunctions["SERVER"] = uf (UserCommands::Server, User::FRIEND, false);
 645   userFunctions["SERVERLIST"] =
 646     uf (UserCommands::ServerList, User::FRIEND, false);
 647   userFunctions["SETVERSION"] =
 648     uf (UserCommands::SetVersion, User::MASTER, false);
 649   userFunctions["SHITLIST"] =
 650     uf (UserCommands::ShitList, User::FRIEND, false);
 651   userFunctions["SPYLIST"] = uf (UserCommands::SpyList, User::USER, false);
 652   userFunctions["SPYMESSAGE"] =
 653     uf (UserCommands::SpyMessage, User::USER, false);
 654   userFunctions["STATS"] = uf (UserCommands::Stats, User::FRIEND, true);
 655   userFunctions["TBAN"] = uf (UserCommands::TBan, User::USER, true);
 656   userFunctions["TKBAN"] = uf (UserCommands::TKBan, User::USER, true);
 657   userFunctions["TOPIC"] = uf (UserCommands::Topic, User::USER, true);
 658   userFunctions["UNLOCK"] = uf (UserCommands::Unlock, User::FRIEND, true);
 659   userFunctions["USERLIST"] =
 660     uf (UserCommands::UserList, User::FRIEND, false);
 661   userFunctions["WHO"] = uf (UserCommands::Who, User::NONE, true);
 662   userFunctions["WHOIS"] = uf (UserCommands::Whois, User::FRIEND, true);
 663 #undef uf
 664 }
 665
 666 namespace
 667 {
 668   void erase_userf (std::pair<std::string, class userFunction*> it)
 669   {
 670     delete it.second;
 671   }
 672 }
 673
 674 void
 675 Bot::destroy_user_functions ()
 676 {
 677   std::for_each (userFunctions.begin (),
 678             userFunctions.end (),
 679             erase_userf);
 680   userFunctions.erase (userFunctions.begin (),
 681                        userFunctions.end ());
 682 }
 683
 684 void
 685 Bot::set_log_file (String name)
 686 {
 687   logFileName = name;
 688   logFile.close ();
 689   logFile.clear ();
 690 #if HAVE_IOSBASE
 691   logFile.open(logs_dir + logFileName, std::ios_base::out |
 692                std::ios_base::ate | std::ios_base::app);
 693 #else
 694   logFile.open(logs_dir + logFileName, ios::out | ios::ate
 695               | ios::app);
 696 #endif
 697
 698   logLine("Starting log.");
 699 }
 700
 701 void
 702 Bot::set_log_dir (String dir)
 703 {
 704   logs_dir = dir;
 705 }