src/message.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  Inspire is copyright (C) 2002-2004 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 <sys/utsname.h>
  26 #include <time.h>
  27 #include <string>
  28 #ifdef GCC3
  29 #include <ext/hash_map>
  30 #else
  31 #include <hash_map>
  32 #endif
  33 #include <map>
  34 #include <sstream>
  35 #include <vector>
  36 #include <deque>
  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 "commands.h"
  44 #include "message.h"
  45 #include "inspstring.h"
  46 #include "dns.h"
  47 #include "helperfuncs.h"
  48
  49 extern int MODCOUNT;
  50 extern std::vector<Module*> modules;
  51 extern std::vector<ircd_module*> factory;
  52 extern time_t TIME;
  53 extern ServerConfig* Config;
  54
  55 /* return 0 or 1 depending if users u and u2 share one or more common channels
  56  * (used by QUIT, NICK etc which arent channel specific notices) */
  57
  58 int common_channels(userrec *u, userrec *u2)
  59 {
  60         if ((!u) || (!u2))
  61         {
  62                 log(DEFAULT,"*** BUG *** common_channels was given an invalid parameter");
  63                 return 0;
  64         }
  65         for (unsigned int i = 0; i < u->chans.size(); i++)
  66         {
  67                 for (unsigned int z = 0; z != u2->chans.size(); z++)
  68                 {
  69                         if ((u->chans[i].channel != NULL) && (u2->chans[z].channel != NULL))
  70                         {
  71                                 if ((!strcasecmp(u->chans[i].channel->name,u2->chans[z].channel->name)) && (u->chans[i].channel) && (u2->chans[z].channel) && (u->registered == 7) && (u2->registered == 7))
  72                                 {
  73                                         if ((c_count(u)) && (c_count(u2)))
  74                                         {
  75                                                 return 1;
  76                                         }
  77                                 }
  78                         }
  79                 }
  80         }
  81         return 0;
  82 }
  83
  84 void tidystring(char* str)
  85 {
  86         // strips out double spaces before a : parameter
  87
  88         char temp[MAXBUF];
  89         bool go_again = true;
  90
  91         if (!str)
  92                 return;
  93
  94         // pointer voodoo++ --w00t
  95         while ((*str) && (*str == ' '))
  96                 str++;
  97
  98         while (go_again)
  99         {
 100                 bool noparse = false;
 101                 int t = 0, a = 0;
 102                 go_again = false;
 103                 const int lenofstr = strlen(str);
 104
 105                 /*
 106                  * by caching strlen() of str, we theoretically avoid 3 expensive calls each time this loop
 107                  * rolls around.. should speed things up a nanosecond or two. ;)
 108                  */
 109
 110                 while (a < lenofstr)
 111                 {
 112                         if ((a < lenofstr - 1) && (noparse == false))
 113                         {
 114                                 if ((str[a] == ' ') && (str[a+1] == ' '))
 115                                 {
 116                                         log(DEBUG,"Tidied extra space out of string: %s",str);
 117                                         go_again = true;
 118                                         a++;
 119                                 }
 120                         }
 121
 122                         if (a < lenofstr - 1)
 123                         {
 124                                 if ((str[a] == ' ') && (str[a+1] == ':'))
 125                                 {
 126                                         noparse = true;
 127                                 }
 128                         }
 129
 130                         temp[t++] = str[a++];
 131                 }
 132
 133                 temp[t] = '\0';
 134                 strlcpy(str,temp,MAXBUF);
 135         }
 136 }
 137
 138 /* chop a string down to 512 characters and preserve linefeed (irc max
 139  * line length) */
 140
 141 void chop(char* str)
 142 {
 143         if (!str)
 144         {
 145                 log(DEBUG,"ERROR! Null string passed to chop()!");
 146                 return;
 147         }
 148         string temp = str;
 149         const char* str2 = temp.c_str();
 150         strlcat(str,str2,MAXBUF);
 151         if (strlen(str) >= 511)
 152         {
 153                 str[510] = '\r';
 154                 str[511] = '\n';
 155                 str[512] = '\0';
 156                 log(DEBUG,"Excess line chopped.");
 157         }
 158 }
 159
 160
 161 void Blocking(int s)
 162 {
 163         int flags;
 164         log(DEBUG,"Blocking: %d",s);
 165         flags = fcntl(s, F_GETFL, 0);
 166         fcntl(s, F_SETFL, flags ^ O_NONBLOCK);
 167 }
 168
 169 void NonBlocking(int s)
 170 {
 171         int flags;
 172         log(DEBUG,"NonBlocking: %d",s);
 173         flags = fcntl(s, F_GETFL, 0);
 174         fcntl(s, F_SETFL, flags | O_NONBLOCK);
 175 }
 176
 177 int CleanAndResolve (char *resolvedHost, const char *unresolvedHost)
 178 {
 179         DNS d(Config->DNSServer);
 180         int fd = d.ReverseLookup(unresolvedHost);
 181         if (fd < 0)
 182                 return 0;
 183         time_t T = time(NULL)+1;
 184         while ((!d.HasResult()) && (time(NULL)<T));
 185         std::string ipaddr = d.GetResult();
 186         strlcpy(resolvedHost,ipaddr.c_str(),MAXBUF);
 187         return (ipaddr != "");
 188 }
 189
 190 int c_count(userrec* u)
 191 {
 192         int z = 0;
 193         for (unsigned int i =0; i < u->chans.size(); i++)
 194                 if (u->chans[i].channel != NULL)
 195                         z++;
 196         return z;
 197
 198 }
 199
 200 bool hasumode(userrec* user, char mode)
 201 {
 202         if (user)
 203         {
 204                 return (strchr(user->modes,mode)>0);
 205         }
 206         else return false;
 207 }
 208
 209
 210 void ChangeName(userrec* user, const char* gecos)
 211 {
 212         if (user->fd > -1)
 213         {
 214                 int MOD_RESULT = 0;
 215                 FOREACH_RESULT(I_OnChangeLocalUserGECOS,OnChangeLocalUserGECOS(user,gecos));
 216                 if (MOD_RESULT)
 217                         return;
 218                 FOREACH_MOD(I_OnChangeName,OnChangeName(user,gecos));
 219         }
 220         strlcpy(user->fullname,gecos,MAXBUF);
 221 }
 222
 223 void ChangeDisplayedHost(userrec* user, const char* host)
 224 {
 225         if (user->fd > -1)
 226         {
 227                 int MOD_RESULT = 0;
 228                 FOREACH_RESULT(I_OnChangeLocalUserHost,OnChangeLocalUserHost(user,host));
 229                 if (MOD_RESULT)
 230                         return;
 231                 FOREACH_MOD(I_OnChangeHost,OnChangeHost(user,host));
 232         }
 233         strlcpy(user->dhost,host,160);
 234 }
 235
 236 /* verify that a user's ident and nickname is valid */
 237
 238 int isident(const char* n)
 239 {
 240         if (!n)
 241
 242         {
 243                 return 0;
 244         }
 245         if (!strcmp(n,""))
 246         {
 247                 return 0;
 248         }
 249         for (unsigned int i = 0; i < strlen(n); i++)
 250         {
 251                 if ((n[i] < 33) || (n[i] > 125))
 252                 {
 253                         return 0;
 254                 }
 255                 /* can't occur ANYWHERE in an Ident! */
 256                 if (strchr("<>,/?:;@'~#=+()*&%$£ \"!",n[i]))
 257                 {
 258                         return 0;
 259                 }
 260         }
 261         return 1;
 262 }
 263
 264
 265 int isnick(const char* n)
 266 {
 267         if (!n)
 268         {
 269                 return 0;
 270         }
 271         if (!strcmp(n,""))
 272         {
 273                 return 0;
 274         }
 275         if (strlen(n) > NICKMAX)
 276         {
 277                 return 0;
 278         }
 279         for (unsigned int i = 0; i != strlen(n); i++)
 280         {
 281                 if ((n[i] < 33) || (n[i] > 125))
 282                 {
 283                         return 0;
 284                 }
 285                 /* can't occur ANYWHERE in a nickname! */
 286                 if (strchr("<>,./?:;@'~#=+()*&%$£ \"!",n[i]))
 287                 {
 288                         return 0;
 289                 }
 290                 /* can't occur as the first char of a nickname... */
 291                 if ((strchr("0123456789",n[i])) && (!i))
 292                 {
 293                         return 0;
 294                 }
 295         }
 296         return 1;
 297 }
 298
 299 /* returns the status character for a given user on a channel, e.g. @ for op,
 300  * % for halfop etc. If the user has several modes set, the highest mode
 301  * the user has must be returned. */
 302
 303 char* cmode(userrec *user, chanrec *chan)
 304 {
 305         if ((!user) || (!chan))
 306         {
 307                 log(DEFAULT,"*** BUG *** cmode was given an invalid parameter");
 308                 return "";
 309         }
 310
 311         for (unsigned int i = 0; i < user->chans.size(); i++)
 312         {
 313                 if (user->chans[i].channel)
 314                 {
 315                         if ((!strcasecmp(user->chans[i].channel->name,chan->name)) && (chan != NULL))
 316                         {
 317                                 if ((user->chans[i].uc_modes & UCMODE_OP) > 0)
 318                                 {
 319                                         return "@";
 320                                 }
 321                                 if ((user->chans[i].uc_modes & UCMODE_HOP) > 0)
 322                                 {
 323                                         return "%";
 324                                 }
 325                                 if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0)
 326                                 {
 327                                         return "+";
 328                                 }
 329                                 return "";
 330                         }
 331                 }
 332         }
 333         return "";
 334 }
 335
 336 /* returns the status value for a given user on a channel, e.g. STATUS_OP for
 337  * op, STATUS_VOICE for voice etc. If the user has several modes set, the
 338  * highest mode the user has must be returned. */
 339
 340 int cstatus(userrec *user, chanrec *chan)
 341 {
 342         if ((!chan) || (!user))
 343         {
 344                 log(DEFAULT,"*** BUG *** cstatus was given an invalid parameter");
 345                 return 0;
 346         }
 347
 348         if (is_uline(user->server))
 349                 return STATUS_OP;
 350
 351         for (unsigned int i = 0; i < user->chans.size(); i++)
 352         {
 353                 if (user->chans[i].channel)
 354                 {
 355                         if ((!strcasecmp(user->chans[i].channel->name,chan->name)) && (chan != NULL))
 356                         {
 357                                 if ((user->chans[i].uc_modes & UCMODE_OP) > 0)
 358                                 {
 359                                         return STATUS_OP;
 360                                 }
 361                                 if ((user->chans[i].uc_modes & UCMODE_HOP) > 0)
 362                                 {
 363                                         return STATUS_HOP;
 364                                 }
 365                                 if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0)
 366                                 {
 367                                         return STATUS_VOICE;
 368                                 }
 369                                 return STATUS_NORMAL;
 370                         }
 371                 }
 372         }
 373         return STATUS_NORMAL;
 374 }
 375
 376 /* returns 1 if user u has channel c in their record, 0 if not */
 377
 378 int has_channel(userrec *u, chanrec *c)
 379 {
 380         if ((!u) || (!c))
 381         {
 382                 log(DEFAULT,"*** BUG *** has_channel was given an invalid parameter");
 383                 return 0;
 384         }
 385         for (unsigned int i =0; i < u->chans.size(); i++)
 386         {
 387                 if (u->chans[i].channel)
 388                 {
 389                         if (!strcasecmp(u->chans[i].channel->name,c->name))
 390                         {
 391                                 return 1;
 392                         }
 393                 }
 394         }
 395         return 0;
 396 }
 397
 398
 399 void TidyBan(char *ban)
 400 {
 401         if (!ban) {
 402                 log(DEFAULT,"*** BUG *** TidyBan was given an invalid parameter");
 403                 return;
 404         }
 405
 406         char temp[MAXBUF],NICK[MAXBUF],IDENT[MAXBUF],HOST[MAXBUF];
 407
 408         strlcpy(temp,ban,MAXBUF);
 409
 410         char* pos_of_pling = strchr(temp,'!');
 411         char* pos_of_at = strchr(temp,'@');
 412
 413         pos_of_pling[0] = '\0';
 414         pos_of_at[0] = '\0';
 415         pos_of_pling++;
 416         pos_of_at++;
 417
 418         strlcpy(NICK,temp,NICKMAX);
 419         strlcpy(IDENT,pos_of_pling,IDENTMAX+1);
 420         strlcpy(HOST,pos_of_at,160);
 421
 422         snprintf(ban,MAXBUF,"%s!%s@%s",NICK,IDENT,HOST);
 423 }
 424
 425 char lst[MAXBUF];
 426
 427 std::string chlist(userrec *user,userrec* source)
 428 {
 429         std::string cmp = "";
 430         std::string lst = "";
 431         log(DEBUG,"chlist: %s",user->nick);
 432         if (!user)
 433         {
 434                 return lst;
 435         }
 436         for (unsigned int i = 0; i < user->chans.size(); i++)
 437         {
 438                 if (user->chans[i].channel != NULL)
 439                 {
 440                         if (user->chans[i].channel->name)
 441                         {
 442                                 cmp = std::string(user->chans[i].channel->name) + " ";
 443                                 if (!strstr(lst.c_str(),cmp.c_str()))
 444                                 {
 445                                         // if the channel is NOT private/secret, OR the source user is on the channel
 446                                         if (((!(user->chans[i].channel->binarymodes & CM_PRIVATE)) && (!(user->chans[i].channel->binarymodes & CM_SECRET))) || (has_channel(source,user->chans[i].channel)))
 447                                         {
 448                                                 lst = lst + std::string(cmode(user,user->chans[i].channel)) + std::string(user->chans[i].channel->name) + " ";
 449                                         }
 450                                 }
 451                         }
 452                 }
 453         }
 454         return lst;
 455 }
 456