src/helperfuncs.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2009 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *          the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 /* $Core */
  15
  16 #include "inspircd.h"
  17 #include "xline.h"
  18 #include "exitcodes.h"
  19
  20 std::string InspIRCd::GetServerDescription(const std::string& servername)
  21 {
  22         std::string description;
  23
  24         FOREACH_MOD(I_OnGetServerDescription,OnGetServerDescription(servername,description));
  25
  26         if (!description.empty())
  27         {
  28                 return description;
  29         }
  30         else
  31         {
  32                 // not a remote server that can be found, it must be me.
  33                 return Config->ServerDesc;
  34         }
  35 }
  36
  37 /* Find a user record by nickname and return a pointer to it */
  38 User* InspIRCd::FindNick(const std::string &nick)
  39 {
  40         if (!nick.empty() && isdigit(*nick.begin()))
  41                 return FindUUID(nick);
  42
  43         user_hash::iterator iter = this->Users->clientlist->find(nick);
  44
  45         if (iter == this->Users->clientlist->end())
  46                 /* Couldn't find it */
  47                 return NULL;
  48
  49         return iter->second;
  50 }
  51
  52 User* InspIRCd::FindNick(const char* nick)
  53 {
  54         if (isdigit(*nick))
  55                 return FindUUID(nick);
  56
  57         user_hash::iterator iter = this->Users->clientlist->find(nick);
  58
  59         if (iter == this->Users->clientlist->end())
  60                 return NULL;
  61
  62         return iter->second;
  63 }
  64
  65 User* InspIRCd::FindNickOnly(const std::string &nick)
  66 {
  67         user_hash::iterator iter = this->Users->clientlist->find(nick);
  68
  69         if (iter == this->Users->clientlist->end())
  70                 return NULL;
  71
  72         return iter->second;
  73 }
  74
  75 User* InspIRCd::FindNickOnly(const char* nick)
  76 {
  77         user_hash::iterator iter = this->Users->clientlist->find(nick);
  78
  79         if (iter == this->Users->clientlist->end())
  80                 return NULL;
  81
  82         return iter->second;
  83 }
  84
  85 User *InspIRCd::FindUUID(const std::string &uid)
  86 {
  87         return FindUUID(uid.c_str());
  88 }
  89
  90 User *InspIRCd::FindUUID(const char *uid)
  91 {
  92         user_hash::iterator finduuid = this->Users->uuidlist->find(uid);
  93
  94         if (finduuid == this->Users->uuidlist->end())
  95                 return NULL;
  96
  97         return finduuid->second;
  98 }
  99
 100 /* find a channel record by channel name and return a pointer to it */
 101 Channel* InspIRCd::FindChan(const char* chan)
 102 {
 103         chan_hash::iterator iter = chanlist->find(chan);
 104
 105         if (iter == chanlist->end())
 106                 /* Couldn't find it */
 107                 return NULL;
 108
 109         return iter->second;
 110 }
 111
 112 Channel* InspIRCd::FindChan(const std::string &chan)
 113 {
 114         chan_hash::iterator iter = chanlist->find(chan);
 115
 116         if (iter == chanlist->end())
 117                 /* Couldn't find it */
 118                 return NULL;
 119
 120         return iter->second;
 121 }
 122
 123 /* Send an error notice to all users, registered or not */
 124 void InspIRCd::SendError(const std::string &s)
 125 {
 126         for (std::vector<LocalUser*>::const_iterator i = this->Users->local_users.begin(); i != this->Users->local_users.end(); i++)
 127         {
 128                 User* u = *i;
 129                 if (u->registered == REG_ALL)
 130                 {
 131                         u->WriteServ("NOTICE %s :%s",u->nick.c_str(),s.c_str());
 132                 }
 133                 else
 134                 {
 135                         /* Unregistered connections receive ERROR, not a NOTICE */
 136                         u->Write("ERROR :" + s);
 137                 }
 138         }
 139 }
 140
 141 /* return channel count */
 142 long InspIRCd::ChannelCount()
 143 {
 144         return chanlist->size();
 145 }
 146
 147 bool InspIRCd::IsValidMask(const std::string &mask)
 148 {
 149         const char* dest = mask.c_str();
 150         int exclamation = 0;
 151         int atsign = 0;
 152
 153         for (const char* i = dest; *i; i++)
 154         {
 155                 /* out of range character, bad mask */
 156                 if (*i < 32 || *i > 126)
 157                 {
 158                         return false;
 159                 }
 160
 161                 switch (*i)
 162                 {
 163                         case '!':
 164                                 exclamation++;
 165                                 break;
 166                         case '@':
 167                                 atsign++;
 168                                 break;
 169                 }
 170         }
 171
 172         /* valid masks only have 1 ! and @ */
 173         if (exclamation != 1 || atsign != 1)
 174                 return false;
 175
 176         return true;
 177 }
 178
 179 /* true for valid channel name, false else */
 180 bool IsChannelHandler::Call(const char *chname, size_t max)
 181 {
 182         const char *c = chname + 1;
 183
 184         /* check for no name - don't check for !*chname, as if it is empty, it won't be '#'! */
 185         if (!chname || *chname != '#')
 186         {
 187                 return false;
 188         }
 189
 190         while (*c)
 191         {
 192                 switch (*c)
 193                 {
 194                         case ' ':
 195                         case ',':
 196                         case 7:
 197                                 return false;
 198                 }
 199
 200                 c++;
 201         }
 202
 203         size_t len = c - chname;
 204         /* too long a name - note funky pointer arithmetic here. */
 205         if (len > max)
 206         {
 207                         return false;
 208         }
 209
 210         return true;
 211 }
 212
 213 /* true for valid nickname, false else */
 214 bool IsNickHandler::Call(const char* n, size_t max)
 215 {
 216         if (!n || !*n)
 217                 return false;
 218
 219         unsigned int p = 0;
 220         for (const char* i = n; *i; i++, p++)
 221         {
 222                 if ((*i >= 'A') && (*i <= '}'))
 223                 {
 224                         /* "A"-"}" can occur anywhere in a nickname */
 225                         continue;
 226                 }
 227
 228                 if ((((*i >= '0') && (*i <= '9')) || (*i == '-')) && (i > n))
 229                 {
 230                         /* "0"-"9", "-" can occur anywhere BUT the first char of a nickname */
 231                         continue;
 232                 }
 233
 234                 /* invalid character! abort */
 235                 return false;
 236         }
 237
 238         /* too long? or not -- pointer arithmetic rocks */
 239         return (p < max);
 240 }
 241
 242 /* return true for good ident, false else */
 243 bool IsIdentHandler::Call(const char* n)
 244 {
 245         if (!n || !*n)
 246                 return false;
 247
 248         for (const char* i = n; *i; i++)
 249         {
 250                 if ((*i >= 'A') && (*i <= '}'))
 251                 {
 252                         continue;
 253                 }
 254
 255                 if (((*i >= '0') && (*i <= '9')) || (*i == '-') || (*i == '.'))
 256                 {
 257                         continue;
 258                 }
 259
 260                 return false;
 261         }
 262
 263         return true;
 264 }
 265
 266 bool IsSIDHandler::Call(const std::string &str)
 267 {
 268         /* Returns true if the string given is exactly 3 characters long,
 269          * starts with a digit, and the other two characters are A-Z or digits
 270          */
 271         return ((str.length() == 3) && isdigit(str[0]) &&
 272                         ((str[1] >= 'A' && str[1] <= 'Z') || isdigit(str[1])) &&
 273                          ((str[2] >= 'A' && str[2] <= 'Z') || isdigit(str[2])));
 274 }
 275
 276 /* open the proper logfile */
 277 bool InspIRCd::OpenLog(char**, int)
 278 {
 279         if (!Config->cmdline.writelog) return true; // Skip opening default log if -nolog
 280
 281         if (Config->cmdline.startup_log.empty())
 282                 Config->cmdline.startup_log = "logs/startup.log";
 283         FILE* startup = fopen(Config->cmdline.startup_log.c_str(), "a+");
 284
 285         if (!startup)
 286         {
 287                 return false;
 288         }
 289
 290         FileWriter* fw = new FileWriter(startup);
 291         FileLogStream *f = new FileLogStream((Config->cmdline.forcedebug ? DEBUG : DEFAULT), fw);
 292
 293         this->Logs->AddLogType("*", f, true);
 294
 295         return true;
 296 }
 297
 298 void InspIRCd::CheckRoot()
 299 {
 300         if (geteuid() == 0)
 301         {
 302                 printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n");
 303                 this->Logs->Log("STARTUP",DEFAULT,"Cant start as root");
 304                 Exit(EXIT_STATUS_ROOT);
 305         }
 306 }
 307
 308 void InspIRCd::SendWhoisLine(User* user, User* dest, int numeric, const std::string &text)
 309 {
 310         std::string copy_text = text;
 311
 312         ModResult MOD_RESULT;
 313         FIRST_MOD_RESULT(OnWhoisLine, MOD_RESULT, (user, dest, numeric, copy_text));
 314
 315         if (MOD_RESULT != MOD_RES_DENY)
 316                 user->WriteServ("%d %s", numeric, copy_text.c_str());
 317 }
 318
 319 void InspIRCd::SendWhoisLine(User* user, User* dest, int numeric, const char* format, ...)
 320 {
 321         char textbuffer[MAXBUF];
 322         va_list argsPtr;
 323         va_start (argsPtr, format);
 324         vsnprintf(textbuffer, MAXBUF, format, argsPtr);
 325         va_end(argsPtr);
 326
 327         this->SendWhoisLine(user, dest, numeric, std::string(textbuffer));
 328 }
 329
 330 /** Refactored by Brain, Jun 2009. Much faster with some clever O(1) array
 331  * lookups and pointer maths.
 332  */
 333 long InspIRCd::Duration(const std::string &str)
 334 {
 335         unsigned char multiplier = 0;
 336         long total = 0;
 337         long times = 1;
 338         long subtotal = 0;
 339
 340         /* Iterate each item in the string, looking for number or multiplier */
 341         for (std::string::const_reverse_iterator i = str.rbegin(); i != str.rend(); ++i)
 342         {
 343                 /* Found a number, queue it onto the current number */
 344                 if ((*i >= '0') && (*i <= '9'))
 345                 {
 346                         subtotal = subtotal + ((*i - '0') * times);
 347                         times = times * 10;
 348                 }
 349                 else
 350                 {
 351                         /* Found something thats not a number, find out how much
 352                          * it multiplies the built up number by, multiply the total
 353                          * and reset the built up number.
 354                          */
 355                         if (subtotal)
 356                                 total += subtotal * duration_multi[multiplier];
 357
 358                         /* Next subtotal please */
 359                         subtotal = 0;
 360                         multiplier = *i;
 361                         times = 1;
 362                 }
 363         }
 364         if (multiplier)
 365         {
 366                 total += subtotal * duration_multi[multiplier];
 367                 subtotal = 0;
 368         }
 369         /* Any trailing values built up are treated as raw seconds */
 370         return total + subtotal;
 371 }
 372
 373 bool InspIRCd::ULine(const std::string& sserver)
 374 {
 375         if (sserver.empty())
 376                 return true;
 377
 378         return (Config->ulines.find(sserver.c_str()) != Config->ulines.end());
 379 }
 380
 381 bool InspIRCd::SilentULine(const std::string& sserver)
 382 {
 383         std::map<irc::string,bool>::iterator n = Config->ulines.find(sserver.c_str());
 384         if (n != Config->ulines.end())
 385                 return n->second;
 386         else
 387                 return false;
 388 }
 389
 390 std::string InspIRCd::TimeString(time_t curtime)
 391 {
 392         return std::string(ctime(&curtime),24);
 393 }
 394
 395 // You should only pass a single character to this.
 396 void InspIRCd::AddExtBanChar(char c)
 397 {
 398         std::string &tok = Config->data005;
 399         std::string::size_type ebpos;
 400
 401         if ((ebpos = tok.find(" EXTBAN=,")) == std::string::npos)
 402         {
 403                 tok.append(" EXTBAN=,");
 404                 tok.push_back(c);
 405         }
 406         else
 407                 tok.insert(ebpos + 9, 1, c);
 408 }