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