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];
 344         va_list argsPtr;
 345         va_start (argsPtr, data);
 346         vsnprintf(textbuffer, MAXBUF, data, argsPtr);
 347         va_end(argsPtr);
 348         chop(textbuffer);
 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,MAXQUIT);
 752                                 strlcpy(check,"*.net *.split",MAXQUIT);
 753                                 quit_munge = true;
 754                         }
 755                 }
 756         }
 757         if ((Config->HideBans) && (total > 13) && (!quit_munge))
 758         {
 759                 char* check = textbuffer;
 760                 if ((*check++ == 'Q') && (*check++ == 'U') && (*check++ == 'I') && (*check++ == 'T') && (*check++ == ' ') && (*check++ == ':'))
 761                 {
 762                         check++;
 763                         if ((*check++ == '-') && (*check++ == 'L') && (*check++ == 'i') && (*check++ == 'n') && (*check++ == 'e') && (*check++ == 'd') && (*check++ == ':'))
 764                         {
 765                                 strlcpy(oper_quit,textbuffer,MAXQUIT);
 766                                 *(--check) = 0;         // We don't need to strlcpy, we just chop it from the :
 767                                 quit_munge = true;
 768                         }
 769                 }
 770         }
 771
 772         memset(&already_sent,0,MAX_DESCRIPTORS);
 773
 774         unsigned int y = u->chans.size();
 775         for (unsigned int i = 0; i < y; i++)
 776         {
 777                 if (u->chans[i].channel)
 778                 {
 779                         std::map<char*,char*> *ulist= u->chans[i].channel->GetUsers();
 780                         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 781                         {
 782                                 char* o = i->second;
 783                                 userrec* otheruser = (userrec*)o;
 784                                 if (u != otheruser)
 785                                 {
 786                                         if ((otheruser->fd > -1) && (!already_sent[otheruser->fd]))
 787                                         {
 788                                                 already_sent[otheruser->fd] = 1;
 789                                                 if (quit_munge)
 790                                                 {
 791                                                         WriteFrom_NoFormat(otheruser->fd,u,*otheruser->oper ? oper_quit : textbuffer);
 792                                                 }
 793                                                 else WriteFrom_NoFormat(otheruser->fd,u,textbuffer);
 794                                         }
 795                                 }
 796                         }
 797                 }
 798         }
 799 }
 800
 801 void WriteCommonExcept_NoFormat(userrec *u, const char* text)
 802 {
 803         if (!u)
 804         {
 805                 log(DEFAULT,"*** BUG *** WriteCommon was given an invalid parameter");
 806                 return;
 807         }
 808
 809         if (u->registered != 7) {
 810                 log(DEFAULT,"*** BUG *** WriteCommon on an unregistered user");
 811                 return;
 812         }
 813
 814         memset(&already_sent,0,MAX_DESCRIPTORS);
 815
 816         unsigned int y = u->chans.size();
 817         for (unsigned int i = 0; i < y; i++)
 818         {
 819                 if (u->chans[i].channel)
 820                 {
 821                         std::map<char*,char*> *ulist= u->chans[i].channel->GetUsers();
 822                         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
 823                         {
 824                                 char* o = i->second;
 825                                 userrec* otheruser = (userrec*)o;
 826                                 if (u != otheruser)
 827                                 {
 828                                         if ((otheruser->fd > -1) && (!already_sent[otheruser->fd]))
 829                                         {
 830                                                 already_sent[otheruser->fd] = 1;
 831                                                 WriteFrom_NoFormat(otheruser->fd,u,text);
 832                                         }
 833                                 }
 834                         }
 835                 }
 836         }
 837 }
 838
 839
 840
 841 void WriteOpers(char* text, ...)
 842 {
 843         if (!text)
 844         {
 845                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 846                 return;
 847         }
 848
 849         char textbuffer[MAXBUF];
 850         va_list argsPtr;
 851         va_start (argsPtr, text);
 852         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 853         va_end(argsPtr);
 854
 855         for (std::vector<userrec*>::iterator i = all_opers.begin(); i != all_opers.end(); i++)
 856         {
 857                 userrec* a = *i;
 858                 if (IS_LOCAL(a))
 859                 {
 860                         if (strchr(a->modes,'s'))
 861                         {
 862                                 // send server notices to all with +s
 863                                 WriteServ(a->fd,"NOTICE %s :%s",a->nick,textbuffer);
 864                         }
 865                 }
 866         }
 867 }
 868
 869 void ServerNoticeAll(char* text, ...)
 870 {
 871         if (!text)
 872                 return;
 873
 874         char textbuffer[MAXBUF];
 875         va_list argsPtr;
 876         va_start (argsPtr, text);
 877         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 878         va_end(argsPtr);
 879
 880         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 881         {
 882                 userrec* t = (userrec*)(*i);
 883                 WriteServ(t->fd,"NOTICE $%s :%s",Config->ServerName,textbuffer);
 884         }
 885 }
 886
 887 void ServerPrivmsgAll(char* text, ...)
 888 {
 889         if (!text)
 890                 return;
 891
 892         char textbuffer[MAXBUF];
 893         va_list argsPtr;
 894         va_start (argsPtr, text);
 895         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 896         va_end(argsPtr);
 897
 898         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 899         {
 900                 userrec* t = (userrec*)(*i);
 901                 WriteServ(t->fd,"PRIVMSG $%s :%s",Config->ServerName,textbuffer);
 902         }
 903 }
 904
 905 void WriteMode(const char* modes, int flags, const char* text, ...)
 906 {
 907         if ((!text) || (!modes) || (!flags))
 908         {
 909                 log(DEFAULT,"*** BUG *** WriteMode was given an invalid parameter");
 910                 return;
 911         }
 912
 913         char textbuffer[MAXBUF];
 914         va_list argsPtr;
 915         va_start (argsPtr, text);
 916         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 917         va_end(argsPtr);
 918         int modelen = strlen(modes);
 919
 920         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 921         {
 922                 userrec* t = (userrec*)(*i);
 923                 bool send_to_user = false;
 924                 if (flags == WM_AND)
 925                 {
 926                         send_to_user = true;
 927                         for (int n = 0; n < modelen; n++)
 928                         {
 929                                 if (!hasumode(t,modes[n]))
 930                                 {
 931                                         send_to_user = false;
 932                                         break;
 933                                 }
 934                         }
 935                 }
 936                 else if (flags == WM_OR)
 937                 {
 938                         send_to_user = false;
 939                         for (int n = 0; n < modelen; n++)
 940                         {
 941                                 if (hasumode(t,modes[n]))
 942                                 {
 943                                         send_to_user = true;
 944                                         break;
 945                                 }
 946                         }
 947                 }
 948                 if (send_to_user)
 949                 {
 950                         WriteServ(t->fd,"NOTICE %s :%s",t->nick,textbuffer);
 951                 }
 952         }
 953 }
 954
 955 void NoticeAll(userrec *source, bool local_only, char* text, ...)
 956 {
 957         if ((!text) || (!source))
 958         {
 959                 log(DEFAULT,"*** BUG *** NoticeAll was given an invalid parameter");
 960                 return;
 961         }
 962
 963         char textbuffer[MAXBUF];
 964         va_list argsPtr;
 965         va_start (argsPtr, text);
 966         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 967         va_end(argsPtr);
 968
 969         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 970         {
 971                 userrec* t = (userrec*)(*i);
 972                 WriteFrom(t->fd,source,"NOTICE $* :%s",textbuffer);
 973         }
 974
 975 }
 976
 977
 978 void WriteWallOps(userrec *source, bool local_only, char* text, ...)
 979 {
 980         if ((!text) || (!source))
 981         {
 982                 log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
 983                 return;
 984         }
 985
 986         char textbuffer[MAXBUF];
 987         va_list argsPtr;
 988         va_start (argsPtr, text);
 989         vsnprintf(textbuffer, MAXBUF, text, argsPtr);
 990         va_end(argsPtr);
 991
 992         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
 993         {
 994                 userrec* t = (userrec*)(*i);
 995                 if ((IS_LOCAL(t)) && (strchr(t->modes,'w')))
 996                 {
 997                         WriteTo(source,t,"WALLOPS :%s",textbuffer);
 998                 }
 999         }
1000 }
1001
1002 /* convert a string to lowercase. Note following special circumstances
1003  * taken from RFC 1459. Many "official" server branches still hold to this
1004  * rule so i will too;
1005  *
1006  *  Because of IRC's scandanavian origin, the characters {}| are
1007  *  considered to be the lower case equivalents of the characters []\,
1008  *  respectively. This is a critical issue when determining the
1009  *  equivalence of two nicknames.
1010  */
1011
1012 void strlower(char *n)
1013 {
1014         if (n)
1015         {
1016                 for (char* t = n; *t; t++)
1017                         *t = lowermap[(unsigned)*t];
1018         }
1019 }
1020
1021 /* Find a user record by nickname and return a pointer to it */
1022
1023 userrec* Find(std::string nick)
1024 {
1025         user_hash::iterator iter = clientlist.find(nick);
1026
1027         if (iter == clientlist.end())
1028                 /* Couldn't find it */
1029                 return NULL;
1030
1031         return iter->second;
1032 }
1033
1034 userrec* Find(const char* nick)
1035 {
1036         if (!nick)
1037                 return NULL;
1038         user_hash::iterator iter = clientlist.find(nick);
1039
1040         if (iter == clientlist.end())
1041                 return NULL;
1042
1043         return iter->second;
1044 }
1045
1046 /* find a channel record by channel name and return a pointer to it */
1047
1048 chanrec* FindChan(const char* chan)
1049 {
1050         if (!chan)
1051         {
1052                 log(DEFAULT,"*** BUG *** Findchan was given an invalid parameter");
1053                 return NULL;
1054         }
1055
1056         chan_hash::iterator iter = chanlist.find(chan);
1057
1058         if (iter == chanlist.end())
1059                 /* Couldn't find it */
1060                 return NULL;
1061
1062         return iter->second;
1063 }
1064
1065
1066 long GetMaxBans(char* name)
1067 {
1068         char CM[MAXBUF];
1069         for (int count = 0; count < Config->ConfValueEnum("banlist",&Config->config_f); count++)
1070         {
1071                 Config->ConfValue("banlist","chan",count,CM,&Config->config_f);
1072                 if (match(name,CM))
1073                 {
1074                         Config->ConfValue("banlist","limit",count,CM,&Config->config_f);
1075                         return atoi(CM);
1076                 }
1077         }
1078         return 64;
1079 }
1080
1081 void purge_empty_chans(userrec* u)
1082 {
1083
1084         int purge = 0;
1085
1086         // firstly decrement the count on each channel
1087         for (unsigned int f = 0; f < u->chans.size(); f++)
1088         {
1089                 if (u->chans[f].channel)
1090                 {
1091                         u->chans[f].channel->DelUser((char*)u);
1092                 }
1093         }
1094
1095         for (unsigned int i = 0; i < u->chans.size(); i++)
1096         {
1097                 if (u->chans[i].channel)
1098                 {
1099                         if (!usercount(u->chans[i].channel))
1100                         {
1101                                 chan_hash::iterator i2 = chanlist.find(u->chans[i].channel->name);
1102                                 /* kill the record */
1103                                 if (i2 != chanlist.end())
1104                                 {
1105                                         log(DEBUG,"del_channel: destroyed: %s",i2->second->name);
1106                                         if (i2->second)
1107                                         {
1108                                                 FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second));
1109                                                 delete i2->second;
1110                                         }
1111                                         chanlist.erase(i2);
1112                                         purge++;
1113                                         u->chans[i].channel = NULL;
1114                                 }
1115                         }
1116                         else
1117                         {
1118                                 log(DEBUG,"skipped purge for %s",u->chans[i].channel->name);
1119                         }
1120                 }
1121         }
1122         log(DEBUG,"completed channel purge, killed %lu",(unsigned long)purge);
1123
1124         DeleteOper(u);
1125 }
1126
1127
1128 char* chanmodes(chanrec *chan, bool showkey)
1129 {
1130         static char scratch[MAXBUF];
1131         static char sparam[MAXBUF];
1132         char* offset = scratch;
1133
1134         if (!chan)
1135         {
1136                 log(DEFAULT,"*** BUG *** chanmodes was given an invalid parameter");
1137                 *scratch = '\0';
1138                 return scratch;
1139         }
1140
1141         *scratch = '\0';
1142         *sparam = '\0';
1143         if (chan->binarymodes & CM_NOEXTERNAL)
1144                 *offset++ = 'n';
1145         if (chan->binarymodes & CM_TOPICLOCK)
1146                 *offset++ = 't';
1147         if (*chan->key)
1148                 *offset++ = 'k';
1149         if (chan->limit)
1150                 *offset++ = 'l';
1151         if (chan->binarymodes & CM_INVITEONLY)
1152                 *offset++ = 'i';
1153         if (chan->binarymodes & CM_MODERATED)
1154                 *offset++ = 'm';
1155         if (chan->binarymodes & CM_SECRET)
1156                 *offset++ = 's';
1157         if (chan->binarymodes & CM_PRIVATE)
1158                 *offset++ = 'p';
1159         if (*chan->key)
1160         {
1161                 snprintf(sparam,MAXBUF," %s",showkey ? chan->key : "<key>");
1162         }
1163         if (chan->limit)
1164         {
1165                 char foo[24];
1166                 sprintf(foo," %lu",(unsigned long)chan->limit);
1167                 strlcat(sparam,foo,MAXBUF);
1168         }
1169         if (*chan->custom_modes)
1170         {
1171                 for (char* t = chan->custom_modes; *t; t++)
1172                         *offset++ = *t;
1173                 for (int z = 0; chan->custom_modes[z]; z++)
1174                 {
1175                         std::string extparam = chan->GetModeParameter(chan->custom_modes[z]);
1176                         if (extparam != "")
1177                         {
1178                                 strlcat(sparam," ",MAXBUF);
1179                                 strlcat(sparam,extparam.c_str(),MAXBUF);
1180                         }
1181                 }
1182         }
1183         /* Null terminate scratch */
1184         *offset = '\0';
1185         strlcat(scratch,sparam,MAXMODES);
1186         return scratch;
1187 }
1188
1189
1190 /* compile a userlist of a channel into a string, each nick seperated by
1191  * spaces and op, voice etc status shown as @ and + */
1192
1193 void userlist(userrec *user,chanrec *c)
1194 {
1195         if ((!c) || (!user))
1196         {
1197                 log(DEFAULT,"*** BUG *** userlist was given an invalid parameter");
1198                 return;
1199         }
1200
1201         snprintf(list,MAXBUF,"353 %s = %s :", user->nick, c->name);
1202
1203         std::map<char*,char*> *ulist= c->GetUsers();
1204         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
1205         {
1206                 char* o = i->second;
1207                 userrec* otheruser = (userrec*)o;
1208                 if ((!has_channel(user,c)) && (strchr(otheruser->modes,'i')))
1209                 {
1210                         /* user is +i, and source not on the channel, does not show
1211                          * nick in NAMES list */
1212                         continue;
1213                 }
1214                 strlcat(list,cmode(otheruser,c),MAXBUF);
1215                 strlcat(list,otheruser->nick,MAXBUF);
1216                 strlcat(list," ",MAXBUF);
1217                 if (strlen(list)>(480-NICKMAX))
1218                 {
1219                         /* list overflowed into
1220                          * multiple numerics */
1221                         WriteServ_NoFormat(user->fd,list);
1222                         snprintf(list,MAXBUF,"353 %s = %s :", user->nick, c->name);
1223                 }
1224         }
1225         /* if whats left in the list isnt empty, send it */
1226         if (list[strlen(list)-1] != ':')
1227         {
1228                 WriteServ_NoFormat(user->fd,list);
1229         }
1230 }
1231
1232 /* return a count of the users on a specific channel accounting for
1233  * invisible users who won't increase the count. e.g. for /LIST */
1234
1235 int usercount_i(chanrec *c)
1236 {
1237         int count = 0;
1238
1239         if (!c)
1240         {
1241                 log(DEFAULT,"*** BUG *** usercount_i was given an invalid parameter");
1242                 return 0;
1243         }
1244
1245         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1246         {
1247                         if (has_channel(i->second,c))
1248                         {
1249                                 if (i->second->registered == 7)
1250                                 {
1251                                         if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i')))
1252                                         {
1253                                                 /* user is +i, and source not on the channel, does not show
1254                                                  * nick in NAMES list */
1255                                                 continue;
1256                                         }
1257                                         count++;
1258                                 }
1259                         }
1260         }
1261         log(DEBUG,"usercount_i: %s %lu",c->name,(unsigned long)count);
1262         return count;
1263 }
1264
1265
1266 int usercount(chanrec *c)
1267 {
1268         return (c ? c->GetUserCounter() : 0);
1269 }
1270
1271
1272 // looks up a users password for their connection class (<ALLOW>/<DENY> tags)
1273
1274 ConnectClass GetClass(userrec *user)
1275 {
1276         for (ClassVector::iterator i = Config->Classes.begin(); i != Config->Classes.end(); i++)
1277         {
1278                 if (match(user->host,i->host.c_str()))
1279                 {
1280                         return *i;
1281                 }
1282         }
1283         return *(Config->Classes.begin());
1284 }
1285
1286 /* sends out an error notice to all connected clients (not to be used
1287  * lightly!) */
1288
1289 void send_error(char *s)
1290 {
1291         log(DEBUG,"send_error: %s",s);
1292         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
1293         {
1294                 userrec* t = (userrec*)(*i);
1295                 if (t->registered == 7)
1296                 {
1297                         WriteServ(t->fd,"NOTICE %s :%s",t->nick,s);
1298                 }
1299                 else
1300                 {
1301                         // fix - unregistered connections receive ERROR, not NOTICE
1302                         Write(t->fd,"ERROR :%s",s);
1303                 }
1304         }
1305 }
1306
1307 void Error(int status)
1308 {
1309         signal (SIGALRM, SIG_IGN);
1310         signal (SIGPIPE, SIG_IGN);
1311         signal (SIGTERM, SIG_IGN);
1312         signal (SIGABRT, SIG_IGN);
1313         signal (SIGSEGV, SIG_IGN);
1314         signal (SIGURG, SIG_IGN);
1315         signal (SIGKILL, SIG_IGN);
1316         log(DEFAULT,"*** fell down a pothole in the road to perfection ***");
1317         send_error("Error! Segmentation fault! save meeeeeeeeeeeeee *splat!*");
1318         Exit(status);
1319 }
1320
1321 // this function counts all users connected, wether they are registered or NOT.
1322 int usercnt(void)
1323 {
1324         return clientlist.size();
1325 }
1326
1327 // this counts only registered users, so that the percentages in /MAP don't mess up when users are sitting in an unregistered state
1328 int registered_usercount(void)
1329 {
1330         int c = 0;
1331         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1332         {
1333                 if (i->second->registered == 7) c++;
1334         }
1335         return c;
1336 }
1337
1338 int usercount_invisible(void)
1339 {
1340         int c = 0;
1341         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1342         {
1343                 if ((i->second->registered == 7) && (strchr(i->second->modes,'i'))) c++;
1344         }
1345         return c;
1346 }
1347
1348 int usercount_opers(void)
1349 {
1350         int c = 0;
1351         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
1352                 if (*i->second->oper) c++;
1353         return c;
1354 }
1355
1356 int usercount_unknown(void)
1357 {
1358         int c = 0;
1359         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
1360         {
1361                 userrec* t = (userrec*)(*i);
1362                 if (t->registered != 7)
1363                         c++;
1364         }
1365         return c;
1366 }
1367
1368 long chancount(void)
1369 {
1370         return chanlist.size();
1371 }
1372
1373 long local_count()
1374 {
1375         int c = 0;
1376         for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
1377         {
1378                 userrec* t = (userrec*)(*i);
1379                 if (t->registered == 7) c++;
1380         }
1381         return c;
1382 }
1383
1384 void ShowMOTD(userrec *user)
1385 {
1386         static char mbuf[MAXBUF];
1387         static char crud[MAXBUF];
1388         std::string WholeMOTD = "";
1389         if (!Config->MOTD.size())
1390         {
1391                 WriteServ(user->fd,"422 %s :Message of the day file is missing.",user->nick);
1392                 return;
1393         }
1394         snprintf(crud,MAXBUF,":%s 372 %s :- ", Config->ServerName, user->nick);
1395         snprintf(mbuf,MAXBUF,":%s 375 %s :- %s message of the day\r\n", Config->ServerName, user->nick, Config->ServerName);
1396         WholeMOTD = WholeMOTD + mbuf;
1397         for (unsigned int i = 0; i < Config->MOTD.size(); i++)
1398                 WholeMOTD = WholeMOTD + std::string(crud) + Config->MOTD[i].c_str() + std::string("\r\n");
1399         snprintf(mbuf,MAXBUF,":%s 376 %s :End of message of the day.\r\n", Config->ServerName, user->nick);
1400         WholeMOTD = WholeMOTD + mbuf;
1401         // only one write operation
1402         if (Config->GetIOHook(user->port))
1403         {
1404                 try
1405                 {
1406                         Config->GetIOHook(user->port)->OnRawSocketWrite(user->fd,(char*)WholeMOTD.c_str(),WholeMOTD.length());
1407                 }
1408                 catch (ModuleException& modexcept)
1409                 {
1410                         log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
1411                 }
1412
1413         }
1414         else
1415         {
1416                 user->AddWriteBuf(WholeMOTD);
1417         }
1418         ServerInstance->stats->statsSent += WholeMOTD.length();
1419 }
1420
1421 void ShowRULES(userrec *user)
1422 {
1423         if (!Config->RULES.size())
1424         {
1425                 WriteServ(user->fd,"NOTICE %s :Rules file is missing.",user->nick);
1426                 return;
1427         }
1428         WriteServ(user->fd,"NOTICE %s :%s rules",user->nick,Config->ServerName);
1429         for (unsigned int i = 0; i < Config->RULES.size(); i++)
1430                 WriteServ(user->fd,"NOTICE %s :%s",user->nick,Config->RULES[i].c_str());
1431         WriteServ(user->fd,"NOTICE %s :End of %s rules.",user->nick,Config->ServerName);
1432 }
1433
1434 // this returns 1 when all modules are satisfied that the user should be allowed onto the irc server
1435 // (until this returns true, a user will block in the waiting state, waiting to connect up to the
1436 // registration timeout maximum seconds)
1437 bool AllModulesReportReady(userrec* user)
1438 {
1439         if (!Config->global_implementation[I_OnCheckReady])
1440                 return true;
1441         for (int i = 0; i <= MODCOUNT; i++)
1442         {
1443                 if (Config->implement_lists[i][I_OnCheckReady])
1444                 {
1445                         int res = modules[i]->OnCheckReady(user);
1446                         if (!res)
1447                                 return false;
1448                 }
1449         }
1450         return true;
1451 }
1452
1453 bool DirValid(char* dirandfile)
1454 {
1455         char work[MAXBUF];
1456         char buffer[MAXBUF], otherdir[MAXBUF];
1457         strlcpy(work,dirandfile,MAXBUF);
1458         int p = strlen(work);
1459         // we just want the dir
1460         while (*work)
1461         {
1462                 if (work[p] == '/')
1463                 {
1464                         work[p] = '\0';
1465                         break;
1466                 }
1467                 work[p--] = '\0';
1468         }
1469         // Get the current working directory
1470         if( getcwd( buffer, MAXBUF ) == NULL )
1471                 return false;
1472         chdir(work);
1473         if( getcwd( otherdir, MAXBUF ) == NULL )
1474                 return false;
1475         chdir(buffer);
1476         if (strlen(otherdir) >= strlen(work))
1477         {
1478                 otherdir[strlen(work)] = '\0';
1479                 if (!strcmp(otherdir,work))
1480                 {
1481                         return true;
1482                 }
1483                 return false;
1484         }
1485         else return false;
1486 }
1487
1488 std::string GetFullProgDir(char** argv, int argc)
1489 {
1490         char work[MAXBUF];
1491         char buffer[MAXBUF], otherdir[MAXBUF];
1492         strlcpy(work,argv[0],MAXBUF);
1493         int p = strlen(work);
1494         // we just want the dir
1495         while (*work)
1496         {
1497                 if (work[p] == '/')
1498                 {
1499                         work[p] = '\0';
1500                         break;
1501                 }
1502                 work[p--] = '\0';
1503         }
1504         // Get the current working directory
1505         if( getcwd( buffer, MAXBUF ) == NULL )
1506                 return "";
1507         chdir(work);
1508         if( getcwd( otherdir, MAXBUF ) == NULL )
1509                 return "";
1510         chdir(buffer);
1511         return otherdir;
1512 }
1513
1514 int InsertMode(std::string &output, const char* mode, unsigned short section)
1515 {
1516         unsigned short currsection = 1;
1517         unsigned int pos = output.find("CHANMODES=", 0) + 10; // +10 for the length of "CHANMODES="
1518
1519         if(section > 4 || section == 0)
1520         {
1521                 log(DEBUG, "InsertMode: CHANMODES doesn't have a section %dh :/", section);
1522                 return 0;
1523         }
1524
1525         for(; pos < output.size(); pos++)
1526         {
1527                 if(section == currsection)
1528                         break;
1529
1530                 if(output[pos] == ',')
1531                         currsection++;
1532         }
1533
1534         output.insert(pos, mode);
1535         return 1;
1536 }
1537
1538 bool IsValidChannelName(const char *chname)
1539 {
1540                 char *c;
1541
1542                 /* check for no name - don't check for !*chname, as if it is empty, it won't be '#'! */
1543                 if (!chname || *chname != '#')
1544                 {
1545                                 return false;
1546                 }
1547
1548                 c = (char *)chname + 1;
1549                 while (*c)
1550                 {
1551                                 switch (*c)
1552                                 {
1553                                                 case ' ':
1554                                                 case ',':
1555                                                 case 7:
1556                                                                 return false;
1557                                 }
1558
1559                                 c++;
1560                 }
1561
1562                 /* too long a name - note funky pointer arithmetic here. */
1563                 if ((c - chname) > CHANMAX)
1564                 {
1565                                 return false;
1566                 }
1567
1568                 return true;
1569 }