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