src/helperfuncs.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include <stdarg.h>
  16 #include "configreader.h"
  17 #include "users.h"
  18 #include "modules.h"
  19 #include "wildcard.h"
  20 #include "mode.h"
  21 #include "xline.h"
  22 #include "exitcodes.h"
  23
  24 static char TIMESTR[26];
  25 static time_t LAST = 0;
  26
  27 /** Log()
  28  *  Write a line of text `text' to the logfile (and stdout, if in nofork) if the level `level'
  29  *  is greater than the configured loglevel.
  30  */
  31 void InspIRCd::Log(int level, const char* text, ...)
  32 {
  33         /* sanity check, just in case */
  34         if (!this->Config)
  35                 return;
  36
  37         /* Do this check again here so that we save pointless vsnprintf calls */
  38         if ((level < Config->LogLevel) && !Config->forcedebug)
  39                 return;
  40
  41         va_list argsPtr;
  42         char textbuffer[65536];
  43
  44         va_start(argsPtr, text);
  45         vsnprintf(textbuffer, 65536, text, argsPtr);
  46         va_end(argsPtr);
  47
  48         this->Log(level, std::string(textbuffer));
  49 }
  50
  51 void InspIRCd::Log(int level, const std::string &text)
  52 {
  53         /* sanity check, just in case */
  54         if (!this->Config)
  55                 return;
  56
  57         /* If we were given -debug we output all messages, regardless of configured loglevel */
  58         if ((level < Config->LogLevel) && !Config->forcedebug)
  59                 return;
  60
  61         if (Time() != LAST)
  62         {
  63                 time_t local = Time();
  64                 struct tm *timeinfo = localtime(&local);
  65
  66                 strlcpy(TIMESTR,asctime(timeinfo),26);
  67                 TIMESTR[24] = ':';
  68                 LAST = Time();
  69         }
  70
  71         if (Config->log_file && Config->writelog)
  72         {
  73                 std::string out = std::string(TIMESTR) + " " + text.c_str() + "\n";
  74                 this->Logger->WriteLogLine(out);
  75         }
  76
  77         if (Config->nofork)
  78         {
  79                 printf("%s %s\n", TIMESTR, text.c_str());
  80         }
  81 }
  82
  83 std::string InspIRCd::GetServerDescription(const char* servername)
  84 {
  85         std::string description;
  86
  87         FOREACH_MOD_I(this,I_OnGetServerDescription,OnGetServerDescription(servername,description));
  88
  89         if (!description.empty())
  90         {
  91                 return description;
  92         }
  93         else
  94         {
  95                 // not a remote server that can be found, it must be me.
  96                 return Config->ServerDesc;
  97         }
  98 }
  99
 100 /* XXX - We don't use WriteMode for this because WriteMode is very slow and
 101  * this isnt. Basically WriteMode has to iterate ALL the users 'n' times for
 102  * the number of modes provided, e.g. if you send WriteMode 'og' to write to
 103  * opers with globops, and you have 2000 users, thats 4000 iterations. WriteOpers
 104  * uses the oper list, which means if you have 2000 users but only 5 opers,
 105  * it iterates 5 times.
 106  */
 107 void InspIRCd::WriteOpers(const char* text, ...)
 108 {
 109         char textbuffer[MAXBUF];
 110         va_list argsPtr;
 111
 112         va_start(argsPtr, text);
 113         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 114         va_end(argsPtr);
 115
 116         this->WriteOpers(std::string(textbuffer));
 117 }
 118
 119 void InspIRCd::WriteOpers(const std::string &text)
 120 {
 121         for (std::vector<userrec*>::iterator i = this->all_opers.begin(); i != this->all_opers.end(); i++)
 122         {
 123                 userrec* a = *i;
 124                 if (IS_LOCAL(a) && a->IsModeSet('s'))
 125                 {
 126                         // send server notices to all with +s
 127                         a->WriteServ("NOTICE %s :%s",a->nick,text.c_str());
 128                 }
 129         }
 130 }
 131
 132 void InspIRCd::ServerNoticeAll(char* text, ...)
 133 {
 134         if (!text)
 135                 return;
 136
 137         char textbuffer[MAXBUF];
 138         char formatbuffer[MAXBUF];
 139         va_list argsPtr;
 140         va_start (argsPtr, text);
 141         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 142         va_end(argsPtr);
 143
 144         snprintf(formatbuffer,MAXBUF,"NOTICE $%s :%s",Config->ServerName,textbuffer);
 145
 146         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 147         {
 148                 userrec* t = *i;
 149                 t->WriteServ(std::string(formatbuffer));
 150         }
 151 }
 152
 153 void InspIRCd::ServerPrivmsgAll(char* text, ...)
 154 {
 155         if (!text)
 156                 return;
 157
 158         char textbuffer[MAXBUF];
 159         char formatbuffer[MAXBUF];
 160         va_list argsPtr;
 161         va_start (argsPtr, text);
 162         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 163         va_end(argsPtr);
 164
 165         snprintf(formatbuffer,MAXBUF,"PRIVMSG $%s :%s",Config->ServerName,textbuffer);
 166
 167         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 168         {
 169                 userrec* t = *i;
 170                 t->WriteServ(std::string(formatbuffer));
 171         }
 172 }
 173
 174 void InspIRCd::WriteMode(const char* modes, int flags, const char* text, ...)
 175 {
 176         char textbuffer[MAXBUF];
 177         int modelen;
 178         va_list argsPtr;
 179
 180         if (!text || !modes || !flags)
 181         {
 182                 this->Log(DEFAULT,"*** BUG *** WriteMode was given an invalid parameter");
 183                 return;
 184         }
 185
 186         va_start(argsPtr, text);
 187         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 188         va_end(argsPtr);
 189         modelen = strlen(modes);
 190
 191         if (flags == WM_AND)
 192         {
 193                 for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 194                 {
 195                         userrec* t = *i;
 196                         bool send_to_user = true;
 197
 198                         for (int n = 0; n < modelen; n++)
 199                         {
 200                                 if (!t->IsModeSet(modes[n]))
 201                                 {
 202                                         send_to_user = false;
 203                                         break;
 204                                 }
 205                         }
 206                         if (send_to_user)
 207                         {
 208                                 t->WriteServ("NOTICE %s :%s", t->nick, textbuffer);
 209                         }
 210                 }
 211         }
 212         else if (flags == WM_OR)
 213         {
 214                 for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 215                 {
 216                         userrec* t = *i;
 217                         bool send_to_user = false;
 218
 219                         for (int n = 0; n < modelen; n++)
 220                         {
 221                                 if (t->IsModeSet(modes[n]))
 222                                 {
 223                                         send_to_user = true;
 224                                         break;
 225                                 }
 226                         }
 227
 228                         if (send_to_user)
 229                         {
 230                                 t->WriteServ("NOTICE %s :%s", t->nick, textbuffer);
 231                         }
 232                 }
 233         }
 234 }
 235
 236 /* Find a user record by nickname and return a pointer to it */
 237 userrec* InspIRCd::FindNick(const std::string &nick)
 238 {
 239         user_hash::iterator iter = clientlist->find(nick);
 240
 241         if (iter == clientlist->end())
 242                 /* Couldn't find it */
 243                 return NULL;
 244
 245         return iter->second;
 246 }
 247
 248 userrec* InspIRCd::FindNick(const char* nick)
 249 {
 250         user_hash::iterator iter = clientlist->find(nick);
 251
 252         if (iter == clientlist->end())
 253                 return NULL;
 254
 255         return iter->second;
 256 }
 257
 258 /* find a channel record by channel name and return a pointer to it */
 259 chanrec* InspIRCd::FindChan(const char* chan)
 260 {
 261         chan_hash::iterator iter = chanlist->find(chan);
 262
 263         if (iter == chanlist->end())
 264                 /* Couldn't find it */
 265                 return NULL;
 266
 267         return iter->second;
 268 }
 269
 270 chanrec* InspIRCd::FindChan(const std::string &chan)
 271 {
 272         chan_hash::iterator iter = chanlist->find(chan);
 273
 274         if (iter == chanlist->end())
 275                 /* Couldn't find it */
 276                 return NULL;
 277
 278         return iter->second;
 279 }
 280
 281 /* Send an error notice to all users, registered or not */
 282 void InspIRCd::SendError(const std::string &s)
 283 {
 284         for (std::vector<userrec*>::const_iterator i = this->local_users.begin(); i != this->local_users.end(); i++)
 285         {
 286                 if ((*i)->registered == REG_ALL)
 287                 {
 288                         (*i)->WriteServ("NOTICE %s :%s",(*i)->nick,s.c_str());
 289                 }
 290                 else
 291                 {
 292                         /* Unregistered connections receive ERROR, not a NOTICE */
 293                         (*i)->Write("ERROR :" + s);
 294                 }
 295                 /* This might generate a whole load of EAGAIN, but we dont really
 296                  * care about this, as if we call SendError something catastrophic
 297                  * has occured anyway, and we wont receive the events for these.
 298                  */
 299                 (*i)->FlushWriteBuf();
 300         }
 301 }
 302
 303 /* this function counts all users connected, wether they are registered or NOT. */
 304 int InspIRCd::UserCount()
 305 {
 306         return clientlist->size();
 307 }
 308
 309 /* this counts only registered users, so that the percentages in /MAP don't mess up when users are sitting in an unregistered state */
 310 int InspIRCd::RegisteredUserCount()
 311 {
 312         return clientlist->size() - this->UnregisteredUserCount();
 313 }
 314
 315 /* return how many users have a given mode e.g. 'a' */
 316 int InspIRCd::ModeCount(const char mode)
 317 {
 318         ModeHandler* mh = this->Modes->FindMode(mode, MODETYPE_USER);
 319
 320         if (mh)
 321                 return mh->GetCount();
 322         else
 323                 return 0;
 324 }
 325
 326 /* wrapper for readability */
 327 int InspIRCd::InvisibleUserCount()
 328 {
 329         return ModeCount('i');
 330 }
 331
 332 /* return how many users are opered */
 333 int InspIRCd::OperCount()
 334 {
 335         return this->all_opers.size();
 336 }
 337
 338 /* return how many users are unregistered */
 339 int InspIRCd::UnregisteredUserCount()
 340 {
 341         return this->unregistered_count;
 342 }
 343
 344 /* return channel count */
 345 long InspIRCd::ChannelCount()
 346 {
 347         return chanlist->size();
 348 }
 349
 350 /* return how many local registered users there are */
 351 long InspIRCd::LocalUserCount()
 352 {
 353         /* Doesnt count unregistered clients */
 354         return (local_users.size() - this->UnregisteredUserCount());
 355 }
 356
 357 /* true for valid channel name, false else */
 358 bool InspIRCd::IsChannel(const char *chname)
 359 {
 360         char *c;
 361
 362         /* check for no name - don't check for !*chname, as if it is empty, it won't be '#'! */
 363         if (!chname || *chname != '#')
 364         {
 365                 return false;
 366         }
 367
 368         c = (char *)chname + 1;
 369         while (*c)
 370         {
 371                 switch (*c)
 372                 {
 373                         case ' ':
 374                         case ',':
 375                         case 7:
 376                                 return false;
 377                 }
 378
 379                 c++;
 380         }
 381
 382         /* too long a name - note funky pointer arithmetic here. */
 383         if ((c - chname) > CHANMAX)
 384         {
 385                         return false;
 386         }
 387
 388         return true;
 389 }
 390
 391 /* true for valid nickname, false else */
 392 bool IsNickHandler::Call(const char* n)
 393 {
 394         if (!n || !*n)
 395                 return false;
 396
 397         int p = 0;
 398         for (char* i = (char*)n; *i; i++, p++)
 399         {
 400                 if ((*i >= 'A') && (*i <= '}'))
 401                 {
 402                         /* "A"-"}" can occur anywhere in a nickname */
 403                         continue;
 404                 }
 405
 406                 if ((((*i >= '0') && (*i <= '9')) || (*i == '-')) && (i > n))
 407                 {
 408                         /* "0"-"9", "-" can occur anywhere BUT the first char of a nickname */
 409                         continue;
 410                 }
 411
 412                 /* invalid character! abort */
 413                 return false;
 414         }
 415
 416         /* too long? or not -- pointer arithmetic rocks */
 417         return (p < NICKMAX - 1);
 418 }
 419
 420 /* return true for good ident, false else */
 421 bool IsIdentHandler::Call(const char* n)
 422 {
 423         if (!n || !*n)
 424                 return false;
 425
 426         for (char* i = (char*)n; *i; i++)
 427         {
 428                 if ((*i >= 'A') && (*i <= '}'))
 429                 {
 430                         continue;
 431                 }
 432
 433                 if (((*i >= '0') && (*i <= '9')) || (*i == '-') || (*i == '.'))
 434                 {
 435                         continue;
 436                 }
 437
 438                 return false;
 439         }
 440
 441         return true;
 442 }
 443
 444 /* open the proper logfile */
 445 void InspIRCd::OpenLog(char** argv, int argc)
 446 {
 447         Config->MyDir = Config->GetFullProgDir();
 448
 449         if (!*this->LogFileName)
 450         {
 451                 if (Config->logpath.empty())
 452                 {
 453                         Config->logpath = Config->MyDir + "/ircd.log";
 454                 }
 455
 456                 Config->log_file = fopen(Config->logpath.c_str(),"a+");
 457         }
 458         else
 459         {
 460                 Config->log_file = fopen(this->LogFileName,"a+");
 461         }
 462
 463         if (!Config->log_file)
 464         {
 465                 printf("ERROR: Could not write to logfile %s: %s\n\n", Config->logpath.c_str(), strerror(errno));
 466                 Exit(EXIT_STATUS_LOG);
 467         }
 468
 469         this->Logger = new FileLogger(this, Config->log_file);
 470 }
 471
 472 void InspIRCd::CheckRoot()
 473 {
 474         if (geteuid() == 0)
 475         {
 476                 printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n");
 477                 this->Log(DEFAULT,"Cant start as root");
 478                 Exit(EXIT_STATUS_ROOT);
 479         }
 480 }
 481
 482 void InspIRCd::CheckDie()
 483 {
 484         if (*Config->DieValue)
 485         {
 486                 printf("WARNING: %s\n\n",Config->DieValue);
 487                 this->Log(DEFAULT,"Died because of <die> tag: %s",Config->DieValue);
 488                 Exit(EXIT_STATUS_DIETAG);
 489         }
 490 }
 491
 492 /* We must load the modules AFTER initializing the socket engine, now */
 493 void InspIRCd::LoadAllModules()
 494 {
 495         char configToken[MAXBUF];
 496         Config->module_names.clear();
 497         this->ModCount = -1;
 498
 499         for (int count = 0; count < Config->ConfValueEnum(Config->config_data, "module"); count++)
 500         {
 501                 Config->ConfValue(Config->config_data, "module", "name", count, configToken, MAXBUF);
 502                 printf_c("[\033[1;32m*\033[0m] Loading module:\t\033[1;32m%s\033[0m\n",configToken);
 503
 504                 if (!this->LoadModule(configToken))
 505                 {
 506                         this->Log(DEFAULT,"There was an error loading the module '%s': %s", configToken, this->ModuleError());
 507                         printf_c("\n[\033[1;31m*\033[0m] There was an error loading the module '%s': %s\n\n", configToken, this->ModuleError());
 508                         Exit(EXIT_STATUS_MODULE);
 509                 }
 510         }
 511         printf_c("\nA total of \033[1;32m%d\033[0m module%s been loaded.\n", this->ModCount+1, this->ModCount+1 == 1 ? " has" : "s have");
 512         this->Log(DEFAULT,"Total loaded modules: %d", this->ModCount+1);
 513 }
 514
 515 void InspIRCd::SendWhoisLine(userrec* user, userrec* dest, int numeric, const std::string &text)
 516 {
 517         std::string copy_text = text;
 518
 519         int MOD_RESULT = 0;
 520         FOREACH_RESULT_I(this, I_OnWhoisLine, OnWhoisLine(user, dest, numeric, copy_text));
 521
 522         if (!MOD_RESULT)
 523                 user->WriteServ("%d %s", numeric, copy_text.c_str());
 524 }
 525
 526 void InspIRCd::SendWhoisLine(userrec* user, userrec* dest, int numeric, const char* format, ...)
 527 {
 528         char textbuffer[MAXBUF];
 529         va_list argsPtr;
 530         va_start (argsPtr, format);
 531         vsnprintf(textbuffer, MAXBUF, format, argsPtr);
 532         va_end(argsPtr);
 533
 534         this->SendWhoisLine(user, dest, numeric, std::string(textbuffer));
 535 }
 536