src/helperfuncs.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 using namespace std;
  18
  19 #include "inspircd_config.h"
  20 #include "inspircd.h"
  21 #include "inspircd_io.h"
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <sys/errno.h>
  25 #include <time.h>
  26 #include <string>
  27 #ifdef GCC3
  28 #include <ext/hash_map>
  29 #else
  30 #include <hash_map>
  31 #endif
  32 #include <sstream>
  33 #include <vector>
  34 #include <deque>
  35 #include <stdarg.h>
  36 #include "connection.h"
  37 #include "users.h"
  38 #include "ctables.h"
  39 #include "globals.h"
  40 #include "modules.h"
  41 #include "dynamic.h"
  42 #include "wildcard.h"
  43 #include "message.h"
  44 #include "mode.h"
  45 #include "xline.h"
  46 #include "commands.h"
  47 #include "inspstring.h"
  48 #include "helperfuncs.h"
  49 #include "hashcomp.h"
  50 #include "typedefs.h"
  51
  52 extern int MODCOUNT;
  53 extern std::vector<Module*> modules;
  54 extern ServerConfig *Config;
  55 extern InspIRCd* ServerInstance;
  56 extern time_t TIME;
  57 extern char lowermap[255];
  58 static char list[MAXBUF];
  59 extern userrec* fd_ref_table[MAX_DESCRIPTORS];
  60 static char already_sent[MAX_DESCRIPTORS];
  61 extern std::vector<userrec*> all_opers;
  62 extern user_hash clientlist;
  63 extern chan_hash chanlist;
  64
  65 extern std::vector<userrec*> local_users;
  66
  67 void log(int level,char *text, ...)
  68 {
  69         va_list argsPtr;
  70         struct tm * timeinfo;
  71         if (level < Config->LogLevel)
  72                 return;
  73         char textbuffer[MAXBUF];
  74         timeinfo = localtime(&TIME);
  75
  76         if (Config->log_file)
  77         {
  78                 char b[26];
  79                 va_start (argsPtr, text);
  80                 vsnprintf(textbuffer, MAXBUF, text, argsPtr);
  81                 va_end(argsPtr);
  82                 strlcpy(b,asctime(timeinfo),26);
  83                 b[24] = ':';    // we know this is the end of the time string
  84                 if (Config->log_file)
  85                         fprintf(Config->log_file,"%s %s\n",b,textbuffer);
  86                 if (Config->nofork)
  87                 {
  88                         // nofork enabled? display it on terminal too
  89                         printf("%s %s\n",b,textbuffer);
  90                 }
  91         }
  92 }
  93
  94 void readfile(file_cache &F, const char* fname)
  95 {
  96         FILE* file;
  97         char linebuf[MAXBUF];
  98
  99         log(DEBUG,"readfile: loading %s",fname);
 100         F.clear();
 101         file =  fopen(fname,"r");
 102         if (file)
 103         {
 104                 while (!feof(file))
 105                 {
 106                         fgets(linebuf,sizeof(linebuf),file);
 107                         linebuf[strlen(linebuf)-1]='\0';
 108                         if (!*linebuf)
 109                         {
 110                                 strcpy(linebuf,"  ");
 111                         }
 112                         if (!feof(file))
 113                         {
 114                                 F.push_back(linebuf);
 115                         }
 116                 }
 117                 fclose(file);
 118         }
 119         else
 120         {
 121                 log(DEBUG,"readfile: failed to load file: %s",fname);
 122         }
 123         log(DEBUG,"readfile: loaded %s, %lu lines",fname,(unsigned long)F.size());
 124 }
 125
 126 void Write_NoFormat(int sock, const char *text)
 127 {
 128         if ((sock < 0) || (!text) || (sock > MAX_DESCRIPTORS))
 129                 return;
 130
 131         char tb[MAXBUF];
 132         int bytes = snprintf(tb,MAXBUF,"%s\r\n",text);
 133         chop(tb);
 134         if (fd_ref_table[sock])
 135         {
 136                 if (Config->GetIOHook(fd_ref_table[sock]->port))
 137                 {
 138                         try
 139                         {
 140                                 Config->GetIOHook(fd_ref_table[sock]->port)->OnRawSocketWrite(sock,tb,bytes);
 141                         }
 142                         catch (ModuleException modexcept)
 143                         {
 144                                 log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 145                         }
 146                 }
 147                 else
 148                 {
 149                         fd_ref_table[sock]->AddWriteBuf(tb);
 150                 }
 151                 ServerInstance->stats->statsSent += bytes;
 152         }
 153         else log(DEFAULT,"ERROR! attempted write to a user with no fd_ref_table entry!!!");
 154 }
 155
 156 void Write(int sock,char *text, ...)
 157 {
 158         if ((sock < 0) || (sock > MAX_DESCRIPTORS))
 159                 return;
 160         if (!text)
 161         {
 162                 log(DEFAULT,"*** BUG *** Write was given an invalid parameter");
 163                 return;
 164         }
 165         va_list argsPtr;
 166         char textbuffer[MAXBUF],tb[MAXBUF];
 167         va_start (argsPtr, text);
 168         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 169         va_end(argsPtr);
 170         int bytes = snprintf(tb,MAXBUF,"%s\r\n",textbuffer);
 171         chop(tb);
 172         if (fd_ref_table[sock])
 173         {
 174                 if (Config->GetIOHook(fd_ref_table[sock]->port))
 175                 {
 176                         try
 177                         {
 178                                 Config->GetIOHook(fd_ref_table[sock]->port)->OnRawSocketWrite(sock,tb,bytes);
 179                         }
 180                         catch (ModuleException modexcept)
 181                         {
 182                                 log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 183                         }
 184                 }
 185                 else
 186                 {
 187                         fd_ref_table[sock]->AddWriteBuf(tb);
 188                 }
 189                 ServerInstance->stats->statsSent += bytes;
 190         }
 191         else log(DEFAULT,"ERROR! attempted write to a user with no fd_ref_table entry!!!");
 192 }
 193
 194 void WriteServ_NoFormat(int sock, const char* text)
 195 {
 196         if ((sock < 0) || (!text) || (sock > MAX_DESCRIPTORS))
 197                 return;
 198         char tb[MAXBUF];
 199         int bytes = snprintf(tb,MAXBUF,":%s %s\r\n",Config->ServerName,text);
 200         chop(tb);
 201         if (fd_ref_table[sock])
 202         {
 203                 if (Config->GetIOHook(fd_ref_table[sock]->port))
 204                 {
 205                         try
 206                         {
 207                                 Config->GetIOHook(fd_ref_table[sock]->port)->OnRawSocketWrite(sock,tb,bytes);
 208                         }
 209                         catch (ModuleException modexcept)
 210                         {
 211                                 log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 212                         }
 213                 }
 214                 else
 215                 {
 216                         fd_ref_table[sock]->AddWriteBuf(tb);
 217                 }
 218                 ServerInstance->stats->statsSent += bytes;
 219         }
 220         else log(DEFAULT,"ERROR! attempted write to a user with no fd_ref_table entry!!!");
 221 }
 222
 223 /* write a server formatted numeric response to a single socket */
 224
 225 void WriteServ(int sock, char* text, ...)
 226 {
 227         if ((sock < 0) || (sock > MAX_DESCRIPTORS))
 228                 return;
 229         if (!text)
 230         {
 231                 log(DEFAULT,"*** BUG *** WriteServ was given an invalid parameter");
 232                 return;
 233         }
 234         va_list argsPtr;
 235         va_start (argsPtr, text);
 236         char textbuffer[MAXBUF],tb[MAXBUF];
 237         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 238         va_end(argsPtr);
 239         int bytes = snprintf(tb,MAXBUF,":%s %s\r\n",Config->ServerName,textbuffer);
 240         chop(tb);
 241         if (fd_ref_table[sock])
 242         {
 243                 if (Config->GetIOHook(fd_ref_table[sock]->port))
 244                 {
 245                         try
 246                         {
 247                                 Config->GetIOHook(fd_ref_table[sock]->port)->OnRawSocketWrite(sock,tb,bytes);
 248                         }
 249                         catch (ModuleException modexcept)
 250                         {
 251                                 log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 252                         }
 253                 }
 254                 else
 255                 {
 256                         fd_ref_table[sock]->AddWriteBuf(tb);
 257                 }
 258                 ServerInstance->stats->statsSent += bytes;
 259         }
 260         else log(DEFAULT,"ERROR! attempted write to a user with no fd_ref_table entry!!!");
 261 }
 262
 263 void WriteFrom_NoFormat(int sock, userrec *user, const char* text)
 264 {
 265         if ((sock < 0) || (!text) || (!user) || (sock > MAX_DESCRIPTORS))
 266                 return;
 267         char tb[MAXBUF];
 268         int bytes = snprintf(tb,MAXBUF,":%s %s\r\n",user->GetFullHost(),text);
 269         chop(tb);
 270         if (fd_ref_table[sock])
 271         {
 272                 if (Config->GetIOHook(fd_ref_table[sock]->port))
 273                 {
 274                         try
 275                         {
 276                                 Config->GetIOHook(fd_ref_table[sock]->port)->OnRawSocketWrite(sock,tb,bytes);
 277                         }
 278                         catch (ModuleException modexcept)
 279                         {
 280                                 log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 281                         }
 282                 }
 283                 else
 284                 {
 285                         fd_ref_table[sock]->AddWriteBuf(tb);
 286                 }
 287                 ServerInstance->stats->statsSent += bytes;
 288         }
 289         else log(DEFAULT,"ERROR! attempted write to a user with no fd_ref_table entry!!!");
 290 }
 291
 292 /* write text from an originating user to originating user */
 293
 294 void WriteFrom(int sock, userrec *user,char* text, ...)
 295 {
 296         if ((sock < 0) || (sock > MAX_DESCRIPTORS))
 297                 return;
 298         if ((!text) || (!user))
 299         {
 300                 log(DEFAULT,"*** BUG *** WriteFrom was given an invalid parameter");
 301                 return;
 302         }
 303         va_list argsPtr;
 304         va_start (argsPtr, text);
 305         char textbuffer[MAXBUF],tb[MAXBUF];
 306         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 307         va_end(argsPtr);
 308         int bytes = snprintf(tb,MAXBUF,":%s %s\r\n",user->GetFullHost(),textbuffer);
 309         chop(tb);
 310         if (fd_ref_table[sock])
 311         {
 312                 if (Config->GetIOHook(fd_ref_table[sock]->port))
 313                 {
 314                         try
 315                         {
 316                                 Config->GetIOHook(fd_ref_table[sock]->port)->OnRawSocketWrite(sock,tb,bytes);
 317                         }
 318                         catch (ModuleException modexcept)
 319                         {
 320                                 log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 321                         }
 322                 }
 323                 else
 324                 {
 325                         fd_ref_table[sock]->AddWriteBuf(tb);
 326                 }
 327                 ServerInstance->stats->statsSent += bytes;
 328         }
 329         else log(DEFAULT,"ERROR! attempted write to a user with no fd_ref_table entry!!!");
 330 }
 331
 332 /* write text to an destination user from a source user (e.g. user privmsg) */
 333
 334 void WriteTo(userrec *source, userrec *dest,char *data, ...)
 335 {
 336         if ((!dest) || (!data))
 337         {
 338                 log(DEFAULT,"*** BUG *** WriteTo was given an invalid parameter");
 339                 return;
 340         }
 341         if (!IS_LOCAL(dest))
 342                 return;
 343         char textbuffer[MAXBUF],tb[MAXBUF];
 344         va_list argsPtr;
 345         va_start (argsPtr, data);
 346         vsnprintf(textbuffer, MAXBUF, data, argsPtr);
 347         va_end(argsPtr);
 348         chop(tb);
 349
 350         // if no source given send it from the server.
 351         if (!source)
 352         {
 353                 WriteServ_NoFormat(dest->fd,textbuffer);
 354         }
 355         else
 356         {
 357                 WriteFrom_NoFormat(dest->fd,source,textbuffer);
 358         }
 359 }
 360
 361 void WriteTo_NoFormat(userrec *source, userrec *dest, const char *data)
 362 {
 363         if ((!dest) || (!data))
 364                 return;
 365         if (!source)
 366         {
 367                 WriteServ_NoFormat(dest->fd,data);
 368         }
 369         else
 370         {
 371                 WriteFrom_NoFormat(dest->fd,source,data);
 372         }
 373 }
 374
 375 /* write formatted text from a source user to all users on a channel
 376  * including the sender (NOT for privmsg, notice etc!) */
 377
 378 void WriteChannel(chanrec* Ptr, userrec* user, char* text, ...)
 379 {
 380         if ((!Ptr) || (!user) || (!text))
 381         {
 382                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 383                 return;
 384         }
 385         char textbuffer[MAXBUF];
 386         va_list argsPtr;
 387         va_start (argsPtr, text);
 388         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 389         va_end(argsPtr);
 390
 391         std::map<char*,char*> *ulist= Ptr->GetUsers();
 392         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 393         {
 394                 char* o = i->second;
 395                 userrec* otheruser = (userrec*)o;
 396                 if (otheruser->fd != FD_MAGIC_NUMBER)
 397                         WriteTo_NoFormat(user,otheruser,textbuffer);
 398         }
 399 }
 400
 401 void WriteChannel_NoFormat(chanrec* Ptr, userrec* user, const char* text)
 402 {
 403         if ((!Ptr) || (!user) || (!text))
 404         {
 405                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 406                 return;
 407         }
 408         std::map<char*,char*> *ulist= Ptr->GetUsers();
 409         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 410         {
 411                 char* o = i->second;
 412                 userrec* otheruser = (userrec*)o;
 413                 if (otheruser->fd != FD_MAGIC_NUMBER)
 414                         WriteTo_NoFormat(user,otheruser,text);
 415         }
 416 }
 417
 418
 419 /* write formatted text from a source user to all users on a channel
 420  * including the sender (NOT for privmsg, notice etc!) doesnt send to
 421  * users on remote servers */
 422
 423 void WriteChannelLocal(chanrec* Ptr, userrec* user, char* text, ...)
 424 {
 425         if ((!Ptr) || (!text))
 426         {
 427                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 428                 return;
 429         }
 430         char textbuffer[MAXBUF];
 431         va_list argsPtr;
 432         va_start (argsPtr, text);
 433         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 434         va_end(argsPtr);
 435
 436         std::map<char*,char*> *ulist= Ptr->GetUsers();
 437         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 438         {
 439                 char* o = i->second;
 440                 userrec* otheruser = (userrec*)o;
 441                 if ((otheruser->fd != FD_MAGIC_NUMBER) && (otheruser != user))
 442                 {
 443                         if (!user)
 444                         {
 445                                 WriteServ_NoFormat(otheruser->fd,textbuffer);
 446                         }
 447                         else
 448                         {
 449                                 WriteTo_NoFormat(user,otheruser,textbuffer);
 450                         }
 451                 }
 452         }
 453 }
 454
 455 void WriteChannelLocal_NoFormat(chanrec* Ptr, userrec* user, const char* text)
 456 {
 457         if ((!Ptr) || (!text))
 458         {
 459                 log(DEFAULT,"*** BUG *** WriteChannel was given an invalid parameter");
 460                 return;
 461         }
 462         std::map<char*,char*> *ulist= Ptr->GetUsers();
 463         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 464         {
 465                 char* o = i->second;
 466                 userrec* otheruser = (userrec*)o;
 467                 if ((otheruser->fd != FD_MAGIC_NUMBER) && (otheruser != user))
 468                 {
 469                         if (!user)
 470                         {
 471                                 WriteServ_NoFormat(otheruser->fd,text);
 472                         }
 473                         else
 474                         {
 475                                 WriteTo_NoFormat(user,otheruser,text);
 476                         }
 477                 }
 478         }
 479 }
 480
 481
 482
 483 void WriteChannelWithServ(char* ServName, chanrec* Ptr, char* text, ...)
 484 {
 485         if ((!Ptr) || (!text))
 486         {
 487                 log(DEFAULT,"*** BUG *** WriteChannelWithServ was given an invalid parameter");
 488                 return;
 489         }
 490         char textbuffer[MAXBUF];
 491         va_list argsPtr;
 492         va_start (argsPtr, text);
 493         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 494         va_end(argsPtr);
 495
 496
 497         std::map<char*,char*> *ulist= Ptr->GetUsers();
 498         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 499         {
 500                 char* o = i->second;
 501                 userrec* otheruser = (userrec*)o;
 502                 if (IS_LOCAL(otheruser))
 503                         WriteServ_NoFormat(otheruser->fd,textbuffer);
 504         }
 505 }
 506
 507 void WriteChannelWithServ_NoFormat(char* ServName, chanrec* Ptr, const char* text)
 508 {
 509         if ((!Ptr) || (!text))
 510         {
 511                 log(DEFAULT,"*** BUG *** WriteChannelWithServ was given an invalid parameter");
 512                 return;
 513         }
 514         std::map<char*,char*> *ulist= Ptr->GetUsers();
 515         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 516         {
 517                 char* o = i->second;
 518                 userrec* otheruser = (userrec*)o;
 519                 if (IS_LOCAL(otheruser))
 520                         WriteServ_NoFormat(otheruser->fd,text);
 521         }
 522 }
 523
 524
 525
 526 /* write formatted text from a source user to all users on a channel except
 527  * for the sender (for privmsg etc) */
 528
 529 void ChanExceptSender(chanrec* Ptr, userrec* user, char status, char* text, ...)
 530 {
 531         if ((!Ptr) || (!user) || (!text))
 532         {
 533                 log(DEFAULT,"*** BUG *** ChanExceptSender was given an invalid parameter");
 534                 return;
 535         }
 536         char textbuffer[MAXBUF];
 537         va_list argsPtr;
 538         va_start (argsPtr, text);
 539         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 540         va_end(argsPtr);
 541
 542         std::map<char*,char*> *ulist;
 543         switch (status)
 544         {
 545                 case '@':
 546                         ulist = Ptr->GetOppedUsers();
 547                 break;
 548                 case '%':
 549                         ulist = Ptr->GetHalfoppedUsers();
 550                 break;
 551                 case '+':
 552                         ulist = Ptr->GetVoicedUsers();
 553                 break;
 554                 default:
 555                         ulist = Ptr->GetUsers();
 556                 break;
 557         }
 558         log(DEBUG,"%d users to write to",ulist->size());
 559         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 560         {
 561                 char* o = i->second;
 562                 userrec* otheruser = (userrec*)o;
 563                 if ((IS_LOCAL(otheruser)) && (user != otheruser))
 564                         WriteFrom_NoFormat(otheruser->fd,user,textbuffer);
 565         }
 566 }
 567
 568 void ChanExceptSender_NoFormat(chanrec* Ptr, userrec* user, char status, const char* text)
 569 {
 570         if ((!Ptr) || (!user) || (!text))
 571         {
 572                 log(DEFAULT,"*** BUG *** ChanExceptSender was given an invalid parameter");
 573                 return;
 574         }
 575         std::map<char*,char*> *ulist;
 576         switch (status)
 577         {
 578                 case '@':
 579                         ulist = Ptr->GetOppedUsers();
 580                 break;
 581                 case '%':
 582                         ulist = Ptr->GetHalfoppedUsers();
 583                 break;
 584                 case '+':
 585                         ulist = Ptr->GetVoicedUsers();
 586                 break;
 587                 default:
 588                         ulist = Ptr->GetUsers();
 589                 break;
 590         }
 591         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 592         {
 593                 char* o = i->second;
 594                 userrec* otheruser = (userrec*)o;
 595                 if ((IS_LOCAL(otheruser)) && (user != otheruser))
 596                         WriteFrom_NoFormat(otheruser->fd,user,text);
 597         }
 598 }
 599
 600 std::string GetServerDescription(char* servername)
 601 {
 602         std::string description = "";
 603         FOREACH_MOD(I_OnGetServerDescription,OnGetServerDescription(servername,description));
 604         if (description != "")
 605         {
 606                 return description;
 607         }
 608         else
 609         {
 610                 return Config->ServerDesc; // not a remote server that can be found, it must be me.
 611         }
 612 }
 613
 614 /* write a formatted string to all users who share at least one common
 615  * channel, including the source user e.g. for use in NICK */
 616
 617 void WriteCommon(userrec *u, char* text, ...)
 618 {
 619         if (!u)
 620         {
 621                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 622                 return;
 623         }
 624
 625         if (u->registered != 7) {
 626                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 627                 return;
 628         }
 629
 630         char textbuffer[MAXBUF];
 631         va_list argsPtr;
 632         va_start (argsPtr, text);
 633         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 634         va_end(argsPtr);
 635
 636         // FIX: Stops a message going to the same person more than once
 637         memset(&already_sent,0,MAX_DESCRIPTORS);
 638
 639         bool sent_to_at_least_one = false;
 640
 641         unsigned int y = u->chans.size();
 642         for (unsigned int i = 0; i < y; i++)
 643         {
 644                 if (u->chans[i].channel)
 645                 {
 646                         std::map<char*,char*> *ulist= u->chans[i].channel->GetUsers();
 647                         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 648                         {
 649                                 char* o = i->second;
 650                                 userrec* otheruser = (userrec*)o;
 651                                 if ((otheruser->fd > -1) && (!already_sent[otheruser->fd]))
 652                                 {
 653                                         already_sent[otheruser->fd] = 1;
 654                                         WriteFrom_NoFormat(otheruser->fd,u,textbuffer);
 655                                         sent_to_at_least_one = true;
 656                                 }
 657                         }
 658                 }
 659         }
 660         // if the user was not in any channels, no users will receive the text. Make sure the user
 661         // receives their OWN message for WriteCommon
 662         if (!sent_to_at_least_one)
 663         {
 664                 WriteFrom_NoFormat(u->fd,u,textbuffer);
 665         }
 666 }
 667
 668 void WriteCommon_NoFormat(userrec *u, const char* text)
 669 {
 670         if (!u)
 671         {
 672                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 673                 return;
 674         }
 675
 676         if (u->registered != 7) {
 677                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 678                 return;
 679         }
 680         // FIX: Stops a message going to the same person more than once
 681         memset(&already_sent,0,MAX_DESCRIPTORS);
 682
 683         bool sent_to_at_least_one = false;
 684
 685         unsigned int y = u->chans.size();
 686         for (unsigned int i = 0; i < y; i++)
 687         {
 688                 if (u->chans[i].channel)
 689                 {
 690                         std::map<char*,char*> *ulist= u->chans[i].channel->GetUsers();
 691                         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 692                         {
 693                                 char* o = i->second;
 694                                 userrec* otheruser = (userrec*)o;
 695                                 if ((otheruser->fd > -1) && (!already_sent[otheruser->fd]))
 696                                 {
 697                                         already_sent[otheruser->fd] = 1;
 698                                         WriteFrom_NoFormat(otheruser->fd,u,text);
 699                                         sent_to_at_least_one = true;
 700                                 }
 701                         }
 702                 }
 703         }
 704         // if the user was not in any channels, no users will receive the text. Make sure the user
 705         // receives their OWN message for WriteCommon
 706         if (!sent_to_at_least_one)
 707         {
 708                 WriteFrom_NoFormat(u->fd,u,text);
 709         }
 710 }
 711
 712
 713 /* write a formatted string to all users who share at least one common
 714  * channel, NOT including the source user e.g. for use in QUIT */
 715
 716 void WriteCommonExcept(userrec *u, char* text, ...)
 717 {
 718         if (!u)
 719         {
 720                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 721                 return;
 722         }
 723
 724         if (u->registered != 7) {
 725                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 726                 return;
 727         }
 728
 729         char textbuffer[MAXBUF];
 730         char oper_quit[MAXBUF];
 731         bool quit_munge = false;
 732
 733         va_list argsPtr;
 734         va_start (argsPtr, text);
 735         int total = vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 736         va_end(argsPtr);
 737
 738         if ((Config->HideSplits) && (total > 6))
 739         {
 740                 /* Yeah yeah, this is ugly. But its fast, live with it. */
 741                 char* check = textbuffer;
 742                 if ((*check++ == 'Q') && (*check++ == 'U') && (*check++ == 'I') && (*check++ == 'T') && (*check++ == ' ') && (*check++ == ':'))
 743                 {
 744                         std::stringstream split(check);
 745                         std::string server_one;
 746                         std::string server_two;
 747                         split >> server_one;
 748                         split >> server_two;
 749                         if ((FindServerName(server_one)) && (FindServerName(server_two)))
 750                         {
 751                                 strlcpy(oper_quit,textbuffer,MAXBUF);
 752                                 strlcpy(check,"*.net *.split",MAXQUIT);
 753                                 quit_munge = true;
 754                         }
 755                 }
 756         }
 757
 758         memset(&already_sent,0,MAX_DESCRIPTORS);
 759
 760         unsigned int y = u->chans.size();
 761         for (unsigned int i = 0; i < y; i++)
 762         {
 763                 if (u->chans[i].channel)
 764                 {
 765                         std::map<char*,char*> *ulist= u->chans[i].channel->GetUsers();
 766                         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 767                         {
 768                                 char* o = i->second;
 769                                 userrec* otheruser = (userrec*)o;
 770                                 if (u != otheruser)
 771                                 {
 772                                         if ((otheruser->fd > -1) && (!already_sent[otheruser->fd]))
 773                                         {
 774                                                 already_sent[otheruser->fd] = 1;
 775                                                 if (quit_munge)
 776                                                 {
 777                                                         if (*otheruser->oper)
 778                                                         {
 779                                                                 WriteFrom_NoFormat(otheruser->fd,u,oper_quit);
 780                                                         }
 781                                                         else
 782                                                         {
 783                                                                 WriteFrom_NoFormat(otheruser->fd,u,textbuffer);
 784                                                         }
 785                                                 }
 786                                                 else WriteFrom_NoFormat(otheruser->fd,u,textbuffer);
 787                                         }
 788                                 }
 789                         }
 790                 }
 791         }
 792 }
 793
 794 void WriteCommonExcept_NoFormat(userrec *u, const char* text)
 795 {
 796         if (!u)
 797         {
 798                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 799                 return;
 800         }
 801
 802         if (u->registered != 7) {
 803                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 804                 return;
 805         }
 806
 807         memset(&already_sent,0,MAX_DESCRIPTORS);
 808
 809         unsigned int y = u->chans.size();
 810         for (unsigned int i = 0; i < y; i++)
 811         {
 812                 if (u->chans[i].channel)
 813                 {
 814                         std::map<char*,char*> *ulist= u->chans[i].channel->GetUsers();
 815                         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 816                         {
 817                                 char* o = i->second;
 818                                 userrec* otheruser = (userrec*)o;
 819                                 if (u != otheruser)
 820                                 {
 821                                         if ((otheruser->fd > -1) && (!already_sent[otheruser->fd]))
 822                                         {
 823                                                 already_sent[otheruser->fd] = 1;
 824                                                 WriteFrom_NoFormat(otheruser->fd,u,text);
 825                                         }
 826                                 }
 827                         }
 828                 }
 829         }
 830 }
 831
 832
 833
 834 void WriteOpers(char* text, ...)
 835 {
 836         if (!text)
 837         {
 838                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 839                 return;
 840         }
 841
 842         char textbuffer[MAXBUF];
 843         va_list argsPtr;
 844         va_start (argsPtr, text);
 845         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 846         va_end(argsPtr);
 847
 848         for (std::vector<userrec*>::iterator i = all_opers.begin(); i != all_opers.end(); i++)
 849         {
 850                 userrec* a = *i;
 851                 if (IS_LOCAL(a))
 852                 {
 853                         if (strchr(a->modes,'s'))
 854                         {
 855                                 // send server notices to all with +s
 856                                 WriteServ(a->fd,"NOTICE %s :%s",a->nick,textbuffer);
 857                         }
 858                 }
 859         }
 860 }
 861
 862 void ServerNoticeAll(char* text, ...)
 863 {
 864         if (!text)
 865                 return;
 866
 867         char textbuffer[MAXBUF];
 868         va_list argsPtr;
 869         va_start (argsPtr, text);
 870         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 871         va_end(argsPtr);
 872
 873         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 874         {
 875                 userrec* t = (userrec*)(*i);
 876                 WriteServ(t->fd,"NOTICE $%s :%s",Config->ServerName,textbuffer);
 877         }
 878 }
 879
 880 void ServerPrivmsgAll(char* text, ...)
 881 {
 882         if (!text)
 883                 return;
 884
 885         char textbuffer[MAXBUF];
 886         va_list argsPtr;
 887         va_start (argsPtr, text);
 888         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 889         va_end(argsPtr);
 890
 891         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 892         {
 893                 userrec* t = (userrec*)(*i);
 894                 WriteServ(t->fd,"PRIVMSG $%s :%s",Config->ServerName,textbuffer);
 895         }
 896 }
 897
 898 void WriteMode(const char* modes, int flags, const char* text, ...)
 899 {
 900         if ((!text) || (!modes) || (!flags))
 901         {
 902                 log(DEFAULT,"*** BUG *** WriteMode was given an invalid parameter");
 903                 return;
 904         }
 905
 906         char textbuffer[MAXBUF];
 907         va_list argsPtr;
 908         va_start (argsPtr, text);
 909         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 910         va_end(argsPtr);
 911         int modelen = strlen(modes);
 912
 913         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 914         {
 915                 userrec* t = (userrec*)(*i);
 916                 bool send_to_user = false;
 917                 if (flags == WM_AND)
 918                 {
 919                         send_to_user = true;
 920                         for (int n = 0; n < modelen; n++)
 921                         {
 922                                 if (!hasumode(t,modes[n]))
 923                                 {
 924                                         send_to_user = false;
 925                                         break;
 926                                 }
 927                         }
 928                 }
 929                 else if (flags == WM_OR)
 930                 {
 931                         send_to_user = false;
 932                         for (int n = 0; n < modelen; n++)
 933                         {
 934                                 if (hasumode(t,modes[n]))
 935                                 {
 936                                         send_to_user = true;
 937                                         break;
 938                                 }
 939                         }
 940                 }
 941                 if (send_to_user)
 942                 {
 943                         WriteServ(t->fd,"NOTICE %s :%s",t->nick,textbuffer);
 944                 }
 945         }
 946 }
 947
 948 void NoticeAll(userrec *source, bool local_only, char* text, ...)
 949 {
 950         if ((!text) || (!source))
 951         {
 952                 log(DEFAULT,"*** BUG *** NoticeAll was given an invalid parameter");
 953                 return;
 954         }
 955
 956         char textbuffer[MAXBUF];
 957         va_list argsPtr;
 958         va_start (argsPtr, text);
 959         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 960         va_end(argsPtr);
 961
 962         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 963         {
 964                 userrec* t = (userrec*)(*i);
 965                 WriteFrom(t->fd,source,"NOTICE $* :%s",textbuffer);
 966         }
 967
 968 }
 969
 970
 971 void WriteWallOps(userrec *source, bool local_only, char* text, ...)
 972 {
 973         if ((!text) || (!source))
 974         {
 975                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 976                 return;
 977         }
 978
 979         char textbuffer[MAXBUF];
 980         va_list argsPtr;
 981         va_start (argsPtr, text);
 982         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 983         va_end(argsPtr);
 984
 985         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 986         {
 987                 userrec* t = (userrec*)(*i);
 988                 if ((IS_LOCAL(t)) && (strchr(t->modes,'w')))
 989                 {
 990                         WriteTo(source,t,"WALLOPS :%s",textbuffer);
 991                 }
 992         }
 993 }
 994
 995 /* convert a string to lowercase. Note following special circumstances
 996  * taken from RFC 1459. Many "official" server branches still hold to this
 997  * rule so i will too;
 998  *
 999  *  Because of IRC's scandanavian origin, the characters {}| are
1000  *  considered to be the lower case equivalents of the characters []\,
1001  *  respectively. This is a critical issue when determining the
1002  *  equivalence of two nicknames.
1003  */
1004
1005 void strlower(char *n)
1006 {
1007         if (n)
1008         {
1009                 for (char* t = n; *t; t++)
1010                         *t = lowermap[(unsigned)*t];
1011         }
1012 }
1013
1014 /* Find a user record by nickname and return a pointer to it */
1015
1016 userrec* Find(std::string nick)
1017 {
1018         user_hash::iterator iter = clientlist.find(nick);
1019
1020         if (iter == clientlist.end())
1021                 /* Couldn't find it */
1022                 return NULL;
1023
1024         return iter->second;
1025 }
1026
1027 /* find a channel record by channel name and return a pointer to it */
1028
1029 chanrec* FindChan(const char* chan)
1030 {
1031         if (!chan)
1032         {
1033                 log(DEFAULT,"*** BUG *** Findchan was given an invalid parameter");
1034                 return NULL;
1035         }
1036
1037         chan_hash::iterator iter = chanlist.find(chan);
1038
1039         if (iter == chanlist.end())
1040                 /* Couldn't find it */
1041                 return NULL;
1042
1043         return iter->second;
1044 }
1045
1046
1047 long GetMaxBans(char* name)
1048 {
1049         char CM[MAXBUF];
1050         for (int count = 0; count < Config->ConfValueEnum("banlist",&Config->config_f); count++)
1051         {
1052                 Config->ConfValue("banlist","chan",count,CM,&Config->config_f);
1053                 if (match(name,CM))
1054                 {
1055                         Config->ConfValue("banlist","limit",count,CM,&Config->config_f);
1056                         return atoi(CM);
1057                 }
1058         }
1059         return 64;
1060 }
1061
1062 void purge_empty_chans(userrec* u)
1063 {
1064
1065         int purge = 0;
1066
1067         // firstly decrement the count on each channel
1068         for (unsigned int f = 0; f < u->chans.size(); f++)
1069         {
1070                 if (u->chans[f].channel)
1071                 {
1072                         u->chans[f].channel->DelUser((char*)u);
1073                 }
1074         }
1075
1076         for (unsigned int i = 0; i < u->chans.size(); i++)
1077         {
1078                 if (u->chans[i].channel)
1079                 {
1080                         if (!usercount(u->chans[i].channel))
1081                         {
1082                                 chan_hash::iterator i2 = chanlist.find(u->chans[i].channel->name);
1083                                 /* kill the record */
1084                                 if (i2 != chanlist.end())
1085                                 {
1086                                         log(DEBUG,"del_channel: destroyed: %s",i2->second->name);
1087                                         if (i2->second)
1088                                         {
1089                                                 FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second));
1090                                                 delete i2->second;
1091                                         }
1092                                         chanlist.erase(i2);
1093                                         purge++;
1094                                         u->chans[i].channel = NULL;
1095                                 }
1096                         }
1097                         else
1098                         {
1099                                 log(DEBUG,"skipped purge for %s",u->chans[i].channel->name);
1100                         }
1101                 }
1102         }
1103         log(DEBUG,"completed channel purge, killed %lu",(unsigned long)purge);
1104
1105         DeleteOper(u);
1106 }
1107
1108
1109 char* chanmodes(chanrec *chan, bool showkey)
1110 {
1111         static char scratch[MAXBUF];
1112         static char sparam[MAXBUF];
1113         char* offset = scratch;
1114
1115         if (!chan)
1116         {
1117                 log(DEFAULT,"*** BUG *** chanmodes was given an invalid parameter");
1118                 *scratch = '\0';
1119                 return scratch;
1120         }
1121
1122         *scratch = '\0';
1123         *sparam = '\0';
1124         if (chan->binarymodes & CM_NOEXTERNAL)
1125                 *offset++ = 'n';
1126         if (chan->binarymodes & CM_TOPICLOCK)
1127                 *offset++ = 't';
1128         if (*chan->key)
1129                 *offset++ = 'k';
1130         if (chan->limit)
1131                 *offset++ = 'l';
1132         if (chan->binarymodes & CM_INVITEONLY)
1133                 *offset++ = 'i';
1134         if (chan->binarymodes & CM_MODERATED)
1135                 *offset++ = 'm';
1136         if (chan->binarymodes & CM_SECRET)
1137                 *offset++ = 's';
1138         if (chan->binarymodes & CM_PRIVATE)
1139                 *offset++ = 'p';
1140         if (*chan->key)
1141         {
1142                 snprintf(sparam,MAXBUF," %s",showkey ? chan->key : "<key>");
1143         }
1144         if (chan->limit)
1145         {
1146                 char foo[24];
1147                 sprintf(foo," %lu",(unsigned long)chan->limit);
1148                 strlcat(sparam,foo,MAXBUF);
1149         }
1150         if (*chan->custom_modes)
1151         {
1152                 for (char* t = chan->custom_modes; *t; t++)
1153                         *offset++ = *t;
1154                 for (int z = 0; chan->custom_modes[z]; z++)
1155                 {
1156                         std::string extparam = chan->GetModeParameter(chan->custom_modes[z]);
1157                         if (extparam != "")
1158                         {
1159                                 strlcat(sparam," ",MAXBUF);
1160                                 strlcat(sparam,extparam.c_str(),MAXBUF);
1161                         }
1162                 }
1163         }
1164         /* Null terminate scratch */
1165         *offset = '\0';
1166         strlcat(scratch,sparam,MAXMODES);
1167         return scratch;
1168 }
1169
1170
1171 /* compile a userlist of a channel into a string, each nick seperated by
1172  * spaces and op, voice etc status shown as @ and + */
1173
1174 void userlist(userrec *user,chanrec *c)
1175 {
1176         if ((!c) || (!user))
1177         {
1178                 log(DEFAULT,"*** BUG *** userlist was given an invalid parameter");
1179                 return;
1180         }
1181
1182         snprintf(list,MAXBUF,"353 %s = %s :", user->nick, c->name);
1183
1184         std::map<char*,char*> *ulist= c->GetUsers();
1185         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
1186         {
1187                 char* o = i->second;
1188                 userrec* otheruser = (userrec*)o;
1189                 if ((!has_channel(user,c)) && (strchr(otheruser->modes,'i')))
1190                 {
1191                         /* user is +i, and source not on the channel, does not show
1192                          * nick in NAMES list */
1193                         continue;
1194                 }
1195                 strlcat(list,cmode(otheruser,c),MAXBUF);
1196                 strlcat(list,otheruser->nick,MAXBUF);
1197                 strlcat(list," ",MAXBUF);
1198                 if (strlen(list)>(480-NICKMAX))
1199                 {
1200                         /* list overflowed into
1201                          * multiple numerics */
1202                         WriteServ_NoFormat(user->fd,list);
1203                         snprintf(list,MAXBUF,"353 %s = %s :", user->nick, c->name);
1204                 }
1205         }
1206         /* if whats left in the list isnt empty, send it */
1207         if (list[strlen(list)-1] != ':')
1208         {
1209                 WriteServ_NoFormat(user->fd,list);
1210         }
1211 }
1212
1213 /* return a count of the users on a specific channel accounting for
1214  * invisible users who won't increase the count. e.g. for /LIST */
1215
1216 int usercount_i(chanrec *c)
1217 {
1218         int count = 0;
1219
1220         if (!c)
1221         {
1222                 log(DEFAULT,"*** BUG *** usercount_i was given an invalid parameter");
1223                 return 0;
1224         }
1225
1226         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1227         {
1228                         if (has_channel(i->second,c))
1229                         {
1230                                 if (i->second->registered == 7)
1231                                 {
1232                                         if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i')))
1233                                         {
1234                                                 /* user is +i, and source not on the channel, does not show
1235                                                  * nick in NAMES list */
1236                                                 continue;
1237                                         }
1238                                         count++;
1239                                 }
1240                         }
1241         }
1242         log(DEBUG,"usercount_i: %s %lu",c->name,(unsigned long)count);
1243         return count;
1244 }
1245
1246
1247 int usercount(chanrec *c)
1248 {
1249         return (c ? c->GetUserCounter() : 0);
1250 }
1251
1252
1253 // looks up a users password for their connection class (<ALLOW>/<DENY> tags)
1254
1255 ConnectClass GetClass(userrec *user)
1256 {
1257         for (ClassVector::iterator i = Config->Classes.begin(); i != Config->Classes.end(); i++)
1258         {
1259                 if (match(user->host,i->host.c_str()))
1260                 {
1261                         return *i;
1262                 }
1263         }
1264         return *(Config->Classes.begin());
1265 }
1266
1267 /* sends out an error notice to all connected clients (not to be used
1268  * lightly!) */
1269
1270 void send_error(char *s)
1271 {
1272         log(DEBUG,"send_error: %s",s);
1273         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
1274         {
1275                 userrec* t = (userrec*)(*i);
1276                 if (t->registered == 7)
1277                 {
1278                         WriteServ(t->fd,"NOTICE %s :%s",t->nick,s);
1279                 }
1280                 else
1281                 {
1282                         // fix - unregistered connections receive ERROR, not NOTICE
1283                         Write(t->fd,"ERROR :%s",s);
1284                 }
1285         }
1286 }
1287
1288 void Error(int status)
1289 {
1290         signal (SIGALRM, SIG_IGN);
1291         signal (SIGPIPE, SIG_IGN);
1292         signal (SIGTERM, SIG_IGN);
1293         signal (SIGABRT, SIG_IGN);
1294         signal (SIGSEGV, SIG_IGN);
1295         signal (SIGURG, SIG_IGN);
1296         signal (SIGKILL, SIG_IGN);
1297         log(DEFAULT,"*** fell down a pothole in the road to perfection ***");
1298         send_error("Error! Segmentation fault! save meeeeeeeeeeeeee *splat!*");
1299         Exit(status);
1300 }
1301
1302 // this function counts all users connected, wether they are registered or NOT.
1303 int usercnt(void)
1304 {
1305         return clientlist.size();
1306 }
1307
1308 // this counts only registered users, so that the percentages in /MAP don't mess up when users are sitting in an unregistered state
1309 int registered_usercount(void)
1310 {
1311         int c = 0;
1312         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1313         {
1314                 if (i->second->registered == 7) c++;
1315         }
1316         return c;
1317 }
1318
1319 int usercount_invisible(void)
1320 {
1321         int c = 0;
1322         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1323         {
1324                 if ((i->second->registered == 7) && (strchr(i->second->modes,'i'))) c++;
1325         }
1326         return c;
1327 }
1328
1329 int usercount_opers(void)
1330 {
1331         int c = 0;
1332         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1333                 if (*i->second->oper) c++;
1334         return c;
1335 }
1336
1337 int usercount_unknown(void)
1338 {
1339         int c = 0;
1340         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
1341         {
1342                 userrec* t = (userrec*)(*i);
1343                 if (t->registered != 7)
1344                         c++;
1345         }
1346         return c;
1347 }
1348
1349 long chancount(void)
1350 {
1351         return chanlist.size();
1352 }
1353
1354 long local_count()
1355 {
1356         int c = 0;
1357         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
1358         {
1359                 userrec* t = (userrec*)(*i);
1360                 if (t->registered == 7) c++;
1361         }
1362         return c;
1363 }
1364
1365 void ShowMOTD(userrec *user)
1366 {
1367         static char mbuf[MAXBUF];
1368         static char crud[MAXBUF];
1369         std::string WholeMOTD = "";
1370         if (!Config->MOTD.size())
1371         {
1372                 WriteServ(user->fd,"422 %s :Message of the day file is missing.",user->nick);
1373                 return;
1374         }
1375         snprintf(crud,MAXBUF,":%s 372 %s :- ", Config->ServerName, user->nick);
1376         snprintf(mbuf,MAXBUF,":%s 375 %s :- %s message of the day\r\n", Config->ServerName, user->nick, Config->ServerName);
1377         WholeMOTD = WholeMOTD + mbuf;
1378         for (unsigned int i = 0; i < Config->MOTD.size(); i++)
1379                 WholeMOTD = WholeMOTD + std::string(crud) + Config->MOTD[i].c_str() + std::string("\r\n");
1380         snprintf(mbuf,MAXBUF,":%s 376 %s :End of message of the day.\r\n", Config->ServerName, user->nick);
1381         WholeMOTD = WholeMOTD + mbuf;
1382         // only one write operation
1383         if (Config->GetIOHook(user->port))
1384         {
1385                 try
1386                 {
1387                         Config->GetIOHook(user->port)->OnRawSocketWrite(user->fd,(char*)WholeMOTD.c_str(),WholeMOTD.length());
1388                 }
1389                 catch (ModuleException modexcept)
1390                 {
1391                         log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
1392                 }
1393
1394         }
1395         else
1396         {
1397                 user->AddWriteBuf(WholeMOTD);
1398         }
1399         ServerInstance->stats->statsSent += WholeMOTD.length();
1400 }
1401
1402 void ShowRULES(userrec *user)
1403 {
1404         if (!Config->RULES.size())
1405         {
1406                 WriteServ(user->fd,"NOTICE %s :Rules file is missing.",user->nick);
1407                 return;
1408         }
1409         WriteServ(user->fd,"NOTICE %s :%s rules",user->nick,Config->ServerName);
1410         for (unsigned int i = 0; i < Config->RULES.size(); i++)
1411                 WriteServ(user->fd,"NOTICE %s :%s",user->nick,Config->RULES[i].c_str());
1412         WriteServ(user->fd,"NOTICE %s :End of %s rules.",user->nick,Config->ServerName);
1413 }
1414
1415 // this returns 1 when all modules are satisfied that the user should be allowed onto the irc server
1416 // (until this returns true, a user will block in the waiting state, waiting to connect up to the
1417 // registration timeout maximum seconds)
1418 bool AllModulesReportReady(userrec* user)
1419 {
1420         if (!Config->global_implementation[I_OnCheckReady])
1421                 return true;
1422         for (int i = 0; i <= MODCOUNT; i++)
1423         {
1424                 if (Config->implement_lists[i][I_OnCheckReady])
1425                 {
1426                         int res = modules[i]->OnCheckReady(user);
1427                         if (!res)
1428                                 return false;
1429                 }
1430         }
1431         return true;
1432 }
1433
1434 bool DirValid(char* dirandfile)
1435 {
1436         char work[MAXBUF];
1437         char buffer[MAXBUF], otherdir[MAXBUF];
1438         strlcpy(work,dirandfile,MAXBUF);
1439         int p = strlen(work);
1440         // we just want the dir
1441         while (*work)
1442         {
1443                 if (work[p] == '/')
1444                 {
1445                         work[p] = '\0';
1446                         break;
1447                 }
1448                 work[p--] = '\0';
1449         }
1450         // Get the current working directory
1451         if( getcwd( buffer, MAXBUF ) == NULL )
1452                 return false;
1453         chdir(work);
1454         if( getcwd( otherdir, MAXBUF ) == NULL )
1455                 return false;
1456         chdir(buffer);
1457         if (strlen(otherdir) >= strlen(work))
1458         {
1459                 otherdir[strlen(work)] = '\0';
1460                 if (!strcmp(otherdir,work))
1461                 {
1462                         return true;
1463                 }
1464                 return false;
1465         }
1466         else return false;
1467 }
1468
1469 std::string GetFullProgDir(char** argv, int argc)
1470 {
1471         char work[MAXBUF];
1472         char buffer[MAXBUF], otherdir[MAXBUF];
1473         strlcpy(work,argv[0],MAXBUF);
1474         int p = strlen(work);
1475         // we just want the dir
1476         while (*work)
1477         {
1478                 if (work[p] == '/')
1479                 {
1480                         work[p] = '\0';
1481                         break;
1482                 }
1483                 work[p--] = '\0';
1484         }
1485         // Get the current working directory
1486         if( getcwd( buffer, MAXBUF ) == NULL )
1487                 return "";
1488         chdir(work);
1489         if( getcwd( otherdir, MAXBUF ) == NULL )
1490                 return "";
1491         chdir(buffer);
1492         return otherdir;
1493 }
1494
1495 int InsertMode(std::string &output, const char* mode, unsigned short section)
1496 {
1497         unsigned short currsection = 1;
1498         unsigned int pos = output.find("CHANMODES=", 0) + 10; // +10 for the length of "CHANMODES="
1499
1500         if(section > 4 || section == 0)
1501         {
1502                 log(DEBUG, "InsertMode: CHANMODES doesn't have a section %dh :/", section);
1503                 return 0;
1504         }
1505
1506         for(; pos < output.size(); pos++)
1507         {
1508                 if(section == currsection)
1509                         break;
1510
1511                 if(output[pos] == ',')
1512                         currsection++;
1513         }
1514
1515         output.insert(pos, mode);
1516         return 1;
1517 }
1518
1519 bool IsValidChannelName(const char *chname)
1520 {
1521                 char *c;
1522
1523                 /* check for no name - don't check for !*chname, as if it is empty, it won't be '#'! */
1524                 if (!chname || *chname != '#')
1525                 {
1526                                 return false;
1527                 }
1528
1529                 c = (char *)chname + 1;
1530                 while (*c)
1531                 {
1532                                 switch (*c)
1533                                 {
1534                                                 case ' ':
1535                                                 case ',':
1536                                                 case 7:
1537                                                                 return false;
1538                                 }
1539
1540                                 c++;
1541                 }
1542
1543                 /* too long a name - note funky pointer arithmetic here. */
1544                 if ((c - chname) > CHANMAX)
1545                 {
1546                                 return false;
1547                 }
1548
1549                 return true;
1550 }