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 || !this->Logger)
  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 || !this->Logger)
  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         if (!nick.empty() && isnumeric(*nick.begin()))
 240                 return FindUUID(nick);
 241
 242         user_hash::iterator iter = clientlist->find(nick);
 243
 244         if (iter == clientlist->end())
 245                 /* Couldn't find it */
 246                 return NULL;
 247
 248         return iter->second;
 249 }
 250
 251 userrec* InspIRCd::FindNick(const char* nick)
 252 {
 253         if (isnumeric(*nick))
 254                 return FindUUID(nick);
 255
 256         user_hash::iterator iter = clientlist->find(nick);
 257
 258         if (iter == clientlist->end())
 259                 return NULL;
 260
 261         return iter->second;
 262 }
 263
 264 userrec *InspIRCd::FindUUID(const std::string &uid)
 265 {
 266         return InspIRCd::FindUUID(uid.c_str());
 267 }
 268
 269 userrec *InspIRCd::FindUUID(const char *uid)
 270 {
 271         for (user_hash::const_iterator a = this->clientlist->begin(); a != this->clientlist->end(); a++)
 272         {
 273                 userrec *u = a->second;
 274
 275                 if (strcmp(u->uuid, uid) == 0)
 276                 {
 277                         return u;
 278                 }
 279         }
 280
 281         return NULL;
 282 }
 283
 284 /* find a channel record by channel name and return a pointer to it */
 285 chanrec* InspIRCd::FindChan(const char* chan)
 286 {
 287         chan_hash::iterator iter = chanlist->find(chan);
 288
 289         if (iter == chanlist->end())
 290                 /* Couldn't find it */
 291                 return NULL;
 292
 293         return iter->second;
 294 }
 295
 296 chanrec* InspIRCd::FindChan(const std::string &chan)
 297 {
 298         chan_hash::iterator iter = chanlist->find(chan);
 299
 300         if (iter == chanlist->end())
 301                 /* Couldn't find it */
 302                 return NULL;
 303
 304         return iter->second;
 305 }
 306
 307 /* Send an error notice to all users, registered or not */
 308 void InspIRCd::SendError(const std::string &s)
 309 {
 310         for (std::vector<userrec*>::const_iterator i = this->local_users.begin(); i != this->local_users.end(); i++)
 311         {
 312                 if ((*i)->registered == REG_ALL)
 313                 {
 314                         (*i)->WriteServ("NOTICE %s :%s",(*i)->nick,s.c_str());
 315                 }
 316                 else
 317                 {
 318                         /* Unregistered connections receive ERROR, not a NOTICE */
 319                         (*i)->Write("ERROR :" + s);
 320                 }
 321                 /* This might generate a whole load of EAGAIN, but we dont really
 322                  * care about this, as if we call SendError something catastrophic
 323                  * has occured anyway, and we wont receive the events for these.
 324                  */
 325                 (*i)->FlushWriteBuf();
 326         }
 327 }
 328
 329 /* this function counts all users connected, wether they are registered or NOT. */
 330 int InspIRCd::UserCount()
 331 {
 332         return clientlist->size();
 333 }
 334
 335 /* this counts only registered users, so that the percentages in /MAP don't mess up when users are sitting in an unregistered state */
 336 int InspIRCd::RegisteredUserCount()
 337 {
 338         return clientlist->size() - this->UnregisteredUserCount();
 339 }
 340
 341 /* return how many users have a given mode e.g. 'a' */
 342 int InspIRCd::ModeCount(const char mode)
 343 {
 344         ModeHandler* mh = this->Modes->FindMode(mode, MODETYPE_USER);
 345
 346         if (mh)
 347                 return mh->GetCount();
 348         else
 349                 return 0;
 350 }
 351
 352 /* wrapper for readability */
 353 int InspIRCd::InvisibleUserCount()
 354 {
 355         return ModeCount('i');
 356 }
 357
 358 /* return how many users are opered */
 359 int InspIRCd::OperCount()
 360 {
 361         return this->all_opers.size();
 362 }
 363
 364 /* return how many users are unregistered */
 365 int InspIRCd::UnregisteredUserCount()
 366 {
 367         return this->unregistered_count;
 368 }
 369
 370 /* return channel count */
 371 long InspIRCd::ChannelCount()
 372 {
 373         return chanlist->size();
 374 }
 375
 376 /* return how many local registered users there are */
 377 long InspIRCd::LocalUserCount()
 378 {
 379         /* Doesnt count unregistered clients */
 380         return (local_users.size() - this->UnregisteredUserCount());
 381 }
 382
 383 /* true for valid channel name, false else */
 384 bool InspIRCd::IsChannel(const char *chname)
 385 {
 386         char *c;
 387
 388         /* check for no name - don't check for !*chname, as if it is empty, it won't be '#'! */
 389         if (!chname || *chname != '#')
 390         {
 391                 return false;
 392         }
 393
 394         c = (char *)chname + 1;
 395         while (*c)
 396         {
 397                 switch (*c)
 398                 {
 399                         case ' ':
 400                         case ',':
 401                         case 7:
 402                                 return false;
 403                 }
 404
 405                 c++;
 406         }
 407
 408         /* too long a name - note funky pointer arithmetic here. */
 409         if ((c - chname) > CHANMAX)
 410         {
 411                         return false;
 412         }
 413
 414         return true;
 415 }
 416
 417 /* true for valid nickname, false else */
 418 bool IsNickHandler::Call(const char* n)
 419 {
 420         if (!n || !*n)
 421                 return false;
 422
 423         int p = 0;
 424         for (char* i = (char*)n; *i; i++, p++)
 425         {
 426                 if ((*i >= 'A') && (*i <= '}'))
 427                 {
 428                         /* "A"-"}" can occur anywhere in a nickname */
 429                         continue;
 430                 }
 431
 432                 if ((((*i >= '0') && (*i <= '9')) || (*i == '-')) && (i > n))
 433                 {
 434                         /* "0"-"9", "-" can occur anywhere BUT the first char of a nickname */
 435                         continue;
 436                 }
 437
 438                 /* invalid character! abort */
 439                 return false;
 440         }
 441
 442         /* too long? or not -- pointer arithmetic rocks */
 443         return (p < NICKMAX - 1);
 444 }
 445
 446 /* return true for good ident, false else */
 447 bool IsIdentHandler::Call(const char* n)
 448 {
 449         if (!n || !*n)
 450                 return false;
 451
 452         for (char* i = (char*)n; *i; i++)
 453         {
 454                 if ((*i >= 'A') && (*i <= '}'))
 455                 {
 456                         continue;
 457                 }
 458
 459                 if (((*i >= '0') && (*i <= '9')) || (*i == '-') || (*i == '.'))
 460                 {
 461                         continue;
 462                 }
 463
 464                 return false;
 465         }
 466
 467         return true;
 468 }
 469
 470 /* open the proper logfile */
 471 bool InspIRCd::OpenLog(char** argv, int argc)
 472 {
 473         Config->MyDir = Config->GetFullProgDir();
 474
 475         if (!*this->LogFileName)
 476         {
 477                 if (Config->logpath.empty())
 478                 {
 479                         Config->logpath = Config->MyDir + "/ircd.log";
 480                 }
 481
 482                 Config->log_file = fopen(Config->logpath.c_str(),"a+");
 483         }
 484         else
 485         {
 486                 Config->log_file = fopen(this->LogFileName,"a+");
 487         }
 488
 489         if (!Config->log_file)
 490         {
 491                 this->Logger = NULL;
 492                 return false;
 493         }
 494
 495         this->Logger = new FileLogger(this, Config->log_file);
 496         return true;
 497 }
 498
 499 void InspIRCd::CheckRoot()
 500 {
 501         if (geteuid() == 0)
 502         {
 503                 printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n");
 504                 this->Log(DEFAULT,"Cant start as root");
 505                 Exit(EXIT_STATUS_ROOT);
 506         }
 507 }
 508
 509 void InspIRCd::CheckDie()
 510 {
 511         if (*Config->DieValue)
 512         {
 513                 printf("WARNING: %s\n\n",Config->DieValue);
 514                 this->Log(DEFAULT,"Died because of <die> tag: %s",Config->DieValue);
 515                 Exit(EXIT_STATUS_DIETAG);
 516         }
 517 }
 518
 519 /* We must load the modules AFTER initializing the socket engine, now */
 520 void InspIRCd::LoadAllModules()
 521 {
 522         char configToken[MAXBUF];
 523         Config->module_names.clear();
 524         this->ModCount = -1;
 525
 526         for (int count = 0; count < Config->ConfValueEnum(Config->config_data, "module"); count++)
 527         {
 528                 Config->ConfValue(Config->config_data, "module", "name", count, configToken, MAXBUF);
 529                 printf_c("[\033[1;32m*\033[0m] Loading module:\t\033[1;32m%s\033[0m\n",configToken);
 530
 531                 if (!this->LoadModule(configToken))
 532                 {
 533                         this->Log(DEFAULT,"There was an error loading the module '%s': %s", configToken, this->ModuleError());
 534                         printf_c("\n[\033[1;31m*\033[0m] There was an error loading the module '%s': %s\n\n", configToken, this->ModuleError());
 535                         Exit(EXIT_STATUS_MODULE);
 536                 }
 537         }
 538         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");
 539         this->Log(DEFAULT,"Total loaded modules: %d", this->ModCount+1);
 540 }
 541
 542 void InspIRCd::SendWhoisLine(userrec* user, userrec* dest, int numeric, const std::string &text)
 543 {
 544         std::string copy_text = text;
 545
 546         int MOD_RESULT = 0;
 547         FOREACH_RESULT_I(this, I_OnWhoisLine, OnWhoisLine(user, dest, numeric, copy_text));
 548
 549         if (!MOD_RESULT)
 550                 user->WriteServ("%d %s", numeric, copy_text.c_str());
 551 }
 552
 553 void InspIRCd::SendWhoisLine(userrec* user, userrec* dest, int numeric, const char* format, ...)
 554 {
 555         char textbuffer[MAXBUF];
 556         va_list argsPtr;
 557         va_start (argsPtr, format);
 558         vsnprintf(textbuffer, MAXBUF, format, argsPtr);
 559         va_end(argsPtr);
 560
 561         this->SendWhoisLine(user, dest, numeric, std::string(textbuffer));
 562 }
 563