ircd/s_user.c

   1 /*
   2  * IRC - Internet Relay Chat, ircd/s_user.c (formerly ircd/s_msg.c)
   3  * Copyright (C) 1990 Jarkko Oikarinen and
   4  *                    University of Oulu, Computing Center
   5  *
   6  * See file AUTHORS in IRC package for additional names of
   7  * the programmers.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 1, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23 /** @file
  24  * @brief Miscellaneous user-related helper functions.
  25  * @version $Id$
  26  */
  27 #include "config.h"
  28
  29 #include "s_user.h"
  30 #include "IPcheck.h"
  31 #include "channel.h"
  32 #include "class.h"
  33 #include "client.h"
  34 #include "hash.h"
  35 #include "ircd.h"
  36 #include "ircd_alloc.h"
  37 #include "ircd_chattr.h"
  38 #include "ircd_features.h"
  39 #include "ircd_log.h"
  40 #include "ircd_reply.h"
  41 #include "ircd_snprintf.h"
  42 #include "ircd_string.h"
  43 #include "list.h"
  44 #include "match.h"
  45 #include "motd.h"
  46 #include "msg.h"
  47 #include "msgq.h"
  48 #include "numeric.h"
  49 #include "numnicks.h"
  50 #include "parse.h"
  51 #include "querycmds.h"
  52 #include "random.h"
  53 #include "s_auth.h"
  54 #include "s_bsd.h"
  55 #include "s_conf.h"
  56 #include "s_debug.h"
  57 #include "s_misc.h"
  58 #include "s_serv.h" /* max_client_count */
  59 #include "send.h"
  60 #include "struct.h"
  61 #include "supported.h"
  62 #include "sys.h"
  63 #include "userload.h"
  64 #include "version.h"
  65 #include "whowas.h"
  66
  67 #include "handlers.h" /* m_motd and m_lusers */
  68
  69 /* #include <assert.h> -- Now using assert in ircd_log.h */
  70 #include <fcntl.h>
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <sys/stat.h>
  75
  76 /** Count of allocated User structures. */
  77 static int userCount = 0;
  78
  79 /** Makes sure that \a cptr has a User information block.
  80  * If cli_user(cptr) != NULL, does nothing.
  81  * @param[in] cptr Client to attach User struct to.
  82  * @return User struct associated with \a cptr.
  83  */
  84 struct User *make_user(struct Client *cptr)
  85 {
  86   assert(0 != cptr);
  87
  88   if (!cli_user(cptr)) {
  89     cli_user(cptr) = (struct User*) MyMalloc(sizeof(struct User));
  90     assert(0 != cli_user(cptr));
  91
  92     /* All variables are 0 by default */
  93     memset(cli_user(cptr), 0, sizeof(struct User));
  94     ++userCount;
  95     cli_user(cptr)->refcnt = 1;
  96   }
  97   return cli_user(cptr);
  98 }
  99
 100 /** Dereference \a user.
 101  * User structures are reference-counted; if the refcount of \a user
 102  * becomes zero, free it.
 103  * @param[in] user User to dereference.
 104  */
 105 void free_user(struct User* user)
 106 {
 107   assert(0 != user);
 108   assert(0 < user->refcnt);
 109
 110   if (--user->refcnt == 0) {
 111     if (user->away)
 112       MyFree(user->away);
 113     /*
 114      * sanity check
 115      */
 116     assert(0 == user->joined);
 117     assert(0 == user->invited);
 118     assert(0 == user->channel);
 119
 120     MyFree(user);
 121     assert(userCount>0);
 122     --userCount;
 123   }
 124 }
 125
 126 /** Find number of User structs allocated and memory used by them.
 127  * @param[out] count_out Receives number of User structs allocated.
 128  * @param[out] bytes_out Receives number of bytes used by User structs.
 129  */
 130 void user_count_memory(size_t* count_out, size_t* bytes_out)
 131 {
 132   assert(0 != count_out);
 133   assert(0 != bytes_out);
 134   *count_out = userCount;
 135   *bytes_out = userCount * sizeof(struct User);
 136 }
 137
 138
 139 /** Find the next client (starting at \a next) with a name that matches \a ch.
 140  * Normal usage loop is:
 141  * for (x = client; x = next_client(x,mask); x = x->next)
 142  *     HandleMatchingClient;
 143  *
 144  * @param[in] next First client to check.
 145  * @param[in] ch Name mask to check against.
 146  * @return Next matching client found, or NULL if none.
 147  */
 148 struct Client *next_client(struct Client *next, const char* ch)
 149 {
 150   struct Client *tmp = next;
 151
 152   if (!tmp)
 153     return NULL;
 154
 155   next = FindClient(ch);
 156   next = next ? next : tmp;
 157   if (cli_prev(tmp) == next)
 158     return NULL;
 159   if (next != tmp)
 160     return next;
 161   for (; next; next = cli_next(next))
 162     if (!match(ch, cli_name(next)))
 163       break;
 164   return next;
 165 }
 166
 167 /** Find the destination server for a command, and forward it if that is not us.
 168  *
 169  * \a server may be a nickname, server name, server mask (if \a from
 170  * is a local user) or server numnick (if \a is a server or remote
 171  * user).
 172  *
 173  * @param[in] from Client that sent the command to us.
 174  * @param[in] cmd Long-form command text.
 175  * @param[in] tok Token-form command text.
 176  * @param[in] one Client that originated the command (ignored).
 177  * @param[in] MustBeOper If non-zero and \a from is not an operator, return HUNTED_NOSUCH.
 178  * @param[in] pattern Format string of arguments to command.
 179  * @param[in] server Index of target name or mask in \a parv.
 180  * @param[in] parc Number of valid elements in \a parv (must be less than 9).
 181  * @param[in] parv Array of arguments to command.
 182  * @return One of HUNTED_ISME, HUNTED_NOSUCH or HUNTED_PASS.
 183  */
 184 int hunt_server_cmd(struct Client *from, const char *cmd, const char *tok,
 185                     struct Client *one, int MustBeOper, const char *pattern,
 186                     int server, int parc, char *parv[])
 187 {
 188   struct Client *acptr;
 189   char *to;
 190
 191   /* Assume it's me, if no server or an unregistered client */
 192   if (parc <= server || EmptyString((to = parv[server])) || IsUnknown(from))
 193     return (HUNTED_ISME);
 194
 195   if (MustBeOper && !IsPrivileged(from))
 196   {
 197     send_reply(from, ERR_NOPRIVILEGES);
 198     return HUNTED_NOSUCH;
 199   }
 200
 201   /* Make sure it's a server */
 202   if (MyUser(from)) {
 203     /* Make sure it's a server */
 204     if (!strchr(to, '*')) {
 205       if (0 == (acptr = FindClient(to))) {
 206         send_reply(from, ERR_NOSUCHSERVER, to);
 207         return HUNTED_NOSUCH;
 208       }
 209
 210       if (cli_user(acptr))
 211         acptr = cli_user(acptr)->server;
 212     } else if (!(acptr = find_match_server(to))) {
 213       send_reply(from, ERR_NOSUCHSERVER, to);
 214       return (HUNTED_NOSUCH);
 215     }
 216   } else if (!(acptr = FindNServer(to))) {
 217     send_reply(from, SND_EXPLICIT | ERR_NOSUCHSERVER, "* :Server has disconnected");
 218     return (HUNTED_NOSUCH);        /* Server broke off in the meantime */
 219   }
 220
 221   if (IsMe(acptr))
 222     return (HUNTED_ISME);
 223
 224   if (MustBeOper && !IsPrivileged(from)) {
 225     send_reply(from, ERR_NOPRIVILEGES);
 226     return HUNTED_NOSUCH;
 227   }
 228
 229   /* assert(!IsServer(from)); */
 230
 231   parv[server] = (char *) acptr; /* HACK! HACK! HACK! ARGH! */
 232
 233   sendcmdto_one(from, cmd, tok, acptr, pattern, parv[1], parv[2], parv[3],
 234                 parv[4], parv[5], parv[6], parv[7], parv[8]);
 235
 236   return (HUNTED_PASS);
 237 }
 238
 239 /** Find the destination server for a command, and forward it (as a
 240  * high-priority command) if that is not us.
 241  *
 242  * \a server may be a nickname, server name, server mask (if \a from
 243  * is a local user) or server numnick (if \a is a server or remote
 244  * user).
 245  * Unlike hunt_server_cmd(), this appends the message to the
 246  * high-priority message queue for the destination server.
 247  *
 248  * @param[in] from Client that sent the command to us.
 249  * @param[in] cmd Long-form command text.
 250  * @param[in] tok Token-form command text.
 251  * @param[in] one Client that originated the command (ignored).
 252  * @param[in] MustBeOper If non-zero and \a from is not an operator, return HUNTED_NOSUCH.
 253  * @param[in] pattern Format string of arguments to command.
 254  * @param[in] server Index of target name or mask in \a parv.
 255  * @param[in] parc Number of valid elements in \a parv (must be less than 9).
 256  * @param[in] parv Array of arguments to command.
 257  * @return One of HUNTED_ISME, HUNTED_NOSUCH or HUNTED_PASS.
 258  */
 259 int hunt_server_prio_cmd(struct Client *from, const char *cmd, const char *tok,
 260                          struct Client *one, int MustBeOper,
 261                          const char *pattern, int server, int parc,
 262                          char *parv[])
 263 {
 264   struct Client *acptr;
 265   char *to;
 266
 267   /* Assume it's me, if no server or an unregistered client */
 268   if (parc <= server || EmptyString((to = parv[server])) || IsUnknown(from))
 269     return (HUNTED_ISME);
 270
 271   /* Make sure it's a server */
 272   if (MyUser(from)) {
 273     /* Make sure it's a server */
 274     if (!strchr(to, '*')) {
 275       if (0 == (acptr = FindClient(to))) {
 276         send_reply(from, ERR_NOSUCHSERVER, to);
 277         return HUNTED_NOSUCH;
 278       }
 279
 280       if (cli_user(acptr))
 281         acptr = cli_user(acptr)->server;
 282     } else if (!(acptr = find_match_server(to))) {
 283       send_reply(from, ERR_NOSUCHSERVER, to);
 284       return (HUNTED_NOSUCH);
 285     }
 286   } else if (!(acptr = FindNServer(to)))
 287     return (HUNTED_NOSUCH);        /* Server broke off in the meantime */
 288
 289   if (IsMe(acptr))
 290     return (HUNTED_ISME);
 291
 292   if (MustBeOper && !IsPrivileged(from)) {
 293     send_reply(from, ERR_NOPRIVILEGES);
 294     return HUNTED_NOSUCH;
 295   }
 296
 297   /* assert(!IsServer(from)); SETTIME to particular destinations permitted */
 298
 299   parv[server] = (char *) acptr; /* HACK! HACK! HACK! ARGH! */
 300
 301   sendcmdto_prio_one(from, cmd, tok, acptr, pattern, parv[1], parv[2], parv[3],
 302                      parv[4], parv[5], parv[6], parv[7], parv[8]);
 303
 304   return (HUNTED_PASS);
 305 }
 306
 307
 308 /*
 309  * register_user
 310  *
 311  * This function is called when both NICK and USER messages
 312  * have been accepted for the client, in whatever order. Only
 313  * after this the USER message is propagated.
 314  *
 315  * NICK's must be propagated at once when received, although
 316  * it would be better to delay them too until full info is
 317  * available. Doing it is not so simple though, would have
 318  * to implement the following:
 319  *
 320  * 1) user telnets in and gives only "NICK foobar" and waits
 321  * 2) another user far away logs in normally with the nick
 322  *    "foobar" (quite legal, as this server didn't propagate it).
 323  * 3) now this server gets nick "foobar" from outside, but
 324  *    has already the same defined locally. Current server
 325  *    would just issue "KILL foobar" to clean out dups. But,
 326  *    this is not fair. It should actually request another
 327  *    nick from local user or kill him/her...
 328  */
 329 /** Finish registering a user who has sent both NICK and USER.
 330  * For local connections, possibly check IAuth; make sure there is a
 331  * matching Client config block; clean the username field; check
 332  * K/k-lines; check for "hacked" looking usernames; assign a numnick;
 333  * and send greeting (WELCOME, ISUPPORT, MOTD, etc).
 334  * For all connections, update the invisible user and operator counts;
 335  * run IPcheck against their address; and forward the NICK.
 336  *
 337  * @param[in] cptr Client who introduced the user.
 338  * @param[in,out] sptr Client who has been fully introduced.
 339  * @return Zero or CPTR_KILLED.
 340  */
 341 int register_user(struct Client *cptr, struct Client *sptr)
 342 {
 343   char*            parv[4];
 344   char*            tmpstr;
 345   struct User*     user = cli_user(sptr);
 346   char             ip_base64[25];
 347
 348   user->last = CurrentTime;
 349   parv[0] = cli_name(sptr);
 350   parv[1] = parv[2] = NULL;
 351
 352   if (MyConnect(sptr))
 353   {
 354     assert(cptr == sptr);
 355
 356     Count_unknownbecomesclient(sptr, UserStats);
 357
 358     SetUser(sptr);
 359     cli_handler(sptr) = CLIENT_HANDLER;
 360     SetLocalNumNick(sptr);
 361     send_reply(sptr,
 362                RPL_WELCOME,
 363                feature_str(FEAT_NETWORK),
 364                feature_str(FEAT_PROVIDER) ? " via " : "",
 365                feature_str(FEAT_PROVIDER) ? feature_str(FEAT_PROVIDER) : "",
 366                cli_name(sptr));
 367     /*
 368      * This is a duplicate of the NOTICE but see below...
 369      */
 370     send_reply(sptr, RPL_YOURHOST, cli_name(&me), version);
 371     send_reply(sptr, RPL_CREATED, creation);
 372     send_reply(sptr, RPL_MYINFO, cli_name(&me), version, infousermodes,
 373                infochanmodes, infochanmodeswithparams);
 374     send_supported(sptr);
 375     m_lusers(sptr, sptr, 1, parv);
 376     update_load();
 377     motd_signon(sptr);
 378     if (cli_snomask(sptr) & SNO_NOISY)
 379       set_snomask(sptr, cli_snomask(sptr) & SNO_NOISY, SNO_ADD);
 380     if (feature_bool(FEAT_CONNEXIT_NOTICES))
 381       sendto_opmask_butone(0, SNO_CONNEXIT,
 382                            "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s%s>",
 383                            cli_name(sptr), user->username, user->host,
 384                            cli_sock_ip(sptr), get_client_class(sptr),
 385                            cli_info(sptr), NumNick(cptr) /* two %s's */);
 386
 387     IPcheck_connect_succeeded(sptr);
 388     /*
 389      * Set user's initial modes
 390      */
 391     tmpstr = (char*)client_get_default_umode(sptr);
 392     if (tmpstr) {
 393       char *umodev[] = { NULL, NULL, NULL, NULL };
 394       umodev[2] = tmpstr;
 395       set_user_mode(cptr, sptr, 1, umodev, ALLOWMODES_ANY);
 396     }
 397
 398   }
 399   else {
 400     struct Client *acptr = user->server;
 401
 402     if (cli_from(acptr) != cli_from(sptr))
 403     {
 404       sendcmdto_one(&me, CMD_KILL, cptr, "%C :%s (%s != %s[%s])",
 405                     sptr, cli_name(&me), cli_name(user->server), cli_name(cli_from(acptr)),
 406                     cli_sockhost(cli_from(acptr)));
 407       SetFlag(sptr, FLAG_KILLED);
 408       return exit_client(cptr, sptr, &me, "NICK server wrong direction");
 409     }
 410     else if (HasFlag(acptr, FLAG_TS8))
 411       SetFlag(sptr, FLAG_TS8);
 412
 413     /*
 414      * Check to see if this user is being propagated
 415      * as part of a net.burst, or is using protocol 9.
 416      * FIXME: This can be sped up - its stupid to check it for
 417      * every NICK message in a burst again  --Run.
 418      */
 419     for (; acptr != &me; acptr = cli_serv(acptr)->up)
 420     {
 421       if (IsBurst(acptr) || Protocol(acptr) < 10)
 422         break;
 423     }
 424     if (!IPcheck_remote_connect(sptr, (acptr != &me)))
 425     {
 426       /*
 427        * We ran out of bits to count this
 428        */
 429       sendcmdto_one(&me, CMD_KILL, sptr, "%C :%s (Too many connections from your host -- Ghost)",
 430                     sptr, cli_name(&me));
 431       return exit_client(cptr, sptr, &me,"Too many connections from your host -- throttled");
 432     }
 433     SetUser(sptr);
 434   }
 435
 436   /* If they get both +x and an account during registration, hide
 437    * their hostmask here.  Calling hide_hostmask() from IAuth's
 438    * account assignment causes a numeric reply during registration.
 439    */
 440   if (HasHiddenHost(sptr))
 441     hide_hostmask(sptr, FLAG_HIDDENHOST);
 442
 443   tmpstr = umode_str(sptr);
 444   /* Send full IP address to IPv6-grokking servers. */
 445   sendcmdto_flag_serv_butone(user->server, CMD_NICK, cptr,
 446                              FLAG_IPV6, FLAG_LAST_FLAG,
 447                              "%s %d %Tu %s %s %s%s%s%s %s%s :%s",
 448                              cli_name(sptr), cli_hopcount(sptr) + 1,
 449                              cli_lastnick(sptr),
 450                              user->username, user->realhost,
 451                              *tmpstr ? "+" : "", tmpstr, *tmpstr ? " " : "",
 452                              iptobase64(ip_base64, &cli_ip(sptr), sizeof(ip_base64), 1),
 453                              NumNick(sptr), cli_info(sptr));
 454   /* Send fake IPv6 addresses to pre-IPv6 servers. */
 455   sendcmdto_flag_serv_butone(user->server, CMD_NICK, cptr,
 456                              FLAG_LAST_FLAG, FLAG_IPV6,
 457                              "%s %d %Tu %s %s %s%s%s%s %s%s :%s",
 458                              cli_name(sptr), cli_hopcount(sptr) + 1,
 459                              cli_lastnick(sptr),
 460                              user->username, user->realhost,
 461                              *tmpstr ? "+" : "", tmpstr, *tmpstr ? " " : "",
 462                              iptobase64(ip_base64, &cli_ip(sptr), sizeof(ip_base64), 0),
 463                              NumNick(sptr), cli_info(sptr));
 464
 465   /* Send user mode to client */
 466   if (MyUser(sptr))
 467   {
 468     static struct Flags flags; /* automatically initialized to zeros */
 469     /* To avoid sending +r to the client due to auth-on-connect, set
 470      * the "old" FLAG_ACCOUNT bit to match the client's value.
 471      */
 472     if (IsAccount(cptr))
 473       FlagSet(&flags, FLAG_ACCOUNT);
 474     else
 475       FlagClr(&flags, FLAG_ACCOUNT);
 476     send_umode(cptr, sptr, &flags, ALL_UMODES);
 477     if ((cli_snomask(sptr) != SNO_DEFAULT) && HasFlag(sptr, FLAG_SERVNOTICE))
 478       send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr));
 479   }
 480   return 0;
 481 }
 482
 483 /** List of user mode characters. */
 484 static const struct UserMode {
 485   unsigned int flag; /**< User mode constant. */
 486   char         c;    /**< Character corresponding to the mode. */
 487 } userModeList[] = {
 488   { FLAG_OPER,        'o' },
 489   { FLAG_LOCOP,       'O' },
 490   { FLAG_INVISIBLE,   'i' },
 491   { FLAG_WALLOP,      'w' },
 492   { FLAG_SERVNOTICE,  's' },
 493   { FLAG_DEAF,        'd' },
 494   { FLAG_CHSERV,      'k' },
 495   { FLAG_DEBUG,       'g' },
 496   { FLAG_ACCOUNT,     'r' },
 497   { FLAG_HIDDENHOST,  'x' }
 498 };
 499
 500 /** Length of #userModeList. */
 501 #define USERMODELIST_SIZE sizeof(userModeList) / sizeof(struct UserMode)
 502
 503 /*
 504  * XXX - find a way to get rid of this
 505  */
 506 /** Nasty global buffer used for communications with umode_str() and others. */
 507 static char umodeBuf[BUFSIZE];
 508
 509 /** Try to set a user's nickname.
 510  * If \a sptr is a server, the client is being introduced for the first time.
 511  * @param[in] cptr Client to set nickname.
 512  * @param[in] sptr Client sending the NICK.
 513  * @param[in] nick New nickname.
 514  * @param[in] parc Number of arguments to NICK.
 515  * @param[in] parv Argument list to NICK.
 516  * @return CPTR_KILLED if \a cptr was killed, else 0.
 517  */
 518 int set_nick_name(struct Client* cptr, struct Client* sptr,
 519                   const char* nick, int parc, char* parv[])
 520 {
 521   if (IsServer(sptr)) {
 522
 523     /*
 524      * A server introducing a new client, change source
 525      */
 526     struct Client* new_client = make_client(cptr, STAT_UNKNOWN);
 527     assert(0 != new_client);
 528
 529     cli_hopcount(new_client) = atoi(parv[2]);
 530     cli_lastnick(new_client) = atoi(parv[3]);
 531
 532     client_set_privs(new_client, NULL); /* set privs on user */
 533     /*
 534      * Set new nick name.
 535      */
 536     strcpy(cli_name(new_client), nick);
 537     cli_user(new_client) = make_user(new_client);
 538     cli_user(new_client)->server = sptr;
 539     SetRemoteNumNick(new_client, parv[parc - 2]);
 540     /*
 541      * IP# of remote client
 542      */
 543     base64toip(parv[parc - 3], &cli_ip(new_client));
 544
 545     add_client_to_list(new_client);
 546     hAddClient(new_client);
 547
 548     cli_serv(sptr)->ghost = 0;        /* :server NICK means end of net.burst */
 549     ircd_strncpy(cli_username(new_client), parv[4], USERLEN);
 550     ircd_strncpy(cli_user(new_client)->username, parv[4], USERLEN);
 551     ircd_strncpy(cli_user(new_client)->host, parv[5], HOSTLEN);
 552     ircd_strncpy(cli_user(new_client)->realhost, parv[5], HOSTLEN);
 553     ircd_strncpy(cli_info(new_client), parv[parc - 1], REALLEN);
 554
 555     Count_newremoteclient(UserStats, sptr);
 556
 557     if (parc > 7 && *parv[6] == '+') {
 558       /* (parc-4) -3 for the ip, numeric nick, realname */
 559       set_user_mode(cptr, new_client, parc-7, parv+4, ALLOWMODES_ANY);
 560     }
 561
 562     return register_user(cptr, new_client);
 563   }
 564   else if ((cli_name(sptr))[0]) {
 565     /*
 566      * Client changing its nick
 567      *
 568      * If the client belongs to me, then check to see
 569      * if client is on any channels where it is currently
 570      * banned.  If so, do not allow the nick change to occur.
 571      */
 572     if (MyUser(sptr)) {
 573       const char* channel_name;
 574       struct Membership *member;
 575       if ((channel_name = find_no_nickchange_channel(sptr))) {
 576         return send_reply(cptr, ERR_BANNICKCHANGE, channel_name);
 577       }
 578       /*
 579        * Refuse nick change if the last nick change was less
 580        * then 30 seconds ago. This is intended to get rid of
 581        * clone bots doing NICK FLOOD. -SeKs
 582        * If someone didn't change their nick for more then 60 seconds
 583        * however, allow to do two nick changes immediately after another
 584        * before limiting the nick flood. -Run
 585        */
 586       if (CurrentTime < cli_nextnick(cptr))
 587       {
 588         cli_nextnick(cptr) += 2;
 589         send_reply(cptr, ERR_NICKTOOFAST, parv[1],
 590                    cli_nextnick(cptr) - CurrentTime);
 591         /* Send error message */
 592         sendcmdto_one(cptr, CMD_NICK, cptr, "%s", cli_name(cptr));
 593         /* bounce NICK to user */
 594         return 0;                /* ignore nick change! */
 595       }
 596       else {
 597         /* Limit total to 1 change per NICK_DELAY seconds: */
 598         cli_nextnick(cptr) += NICK_DELAY;
 599         /* However allow _maximal_ 1 extra consecutive nick change: */
 600         if (cli_nextnick(cptr) < CurrentTime)
 601           cli_nextnick(cptr) = CurrentTime;
 602       }
 603       /* Invalidate all bans against the user so we check them again */
 604       for (member = (cli_user(cptr))->channel; member;
 605            member = member->next_channel)
 606         ClearBanValid(member);
 607     }
 608     /*
 609      * Also set 'lastnick' to current time, if changed.
 610      */
 611     if (0 != ircd_strcmp(parv[0], nick))
 612       cli_lastnick(sptr) = (sptr == cptr) ? TStime() : atoi(parv[2]);
 613
 614     /*
 615      * Client just changing his/her nick. If he/she is
 616      * on a channel, send note of change to all clients
 617      * on that channel. Propagate notice to other servers.
 618      */
 619     if (IsUser(sptr)) {
 620       sendcmdto_common_channels_butone(sptr, CMD_NICK, NULL, ":%s", nick);
 621       add_history(sptr, 1);
 622       sendcmdto_serv_butone(sptr, CMD_NICK, cptr, "%s %Tu", nick,
 623                             cli_lastnick(sptr));
 624     }
 625     else
 626       sendcmdto_one(sptr, CMD_NICK, sptr, ":%s", nick);
 627
 628     if ((cli_name(sptr))[0])
 629       hRemClient(sptr);
 630     strcpy(cli_name(sptr), nick);
 631     hAddClient(sptr);
 632   }
 633   else {
 634     /* Local client setting NICK the first time */
 635     strcpy(cli_name(sptr), nick);
 636     hAddClient(sptr);
 637     return auth_set_nick(cli_auth(sptr), nick);
 638   }
 639   return 0;
 640 }
 641
 642 /** Calculate the hash value for a target.
 643  * @param[in] target Pointer to target, cast to unsigned int.
 644  * @return Hash value constructed from the pointer.
 645  */
 646 static unsigned char hash_target(unsigned int target)
 647 {
 648   return (unsigned char) (target >> 16) ^ (target >> 8);
 649 }
 650
 651 /** Records \a target as a recent target for \a sptr.
 652  * @param[in] sptr User who has sent to a new target.
 653  * @param[in] target Target to add.
 654  */
 655 void
 656 add_target(struct Client *sptr, void *target)
 657 {
 658   /* Ok, this shouldn't work esp on alpha
 659   */
 660   unsigned char  hash = hash_target((unsigned long) target);
 661   unsigned char* targets;
 662   int            i;
 663   assert(0 != sptr);
 664   assert(cli_local(sptr));
 665
 666   targets = cli_targets(sptr);
 667
 668   /*
 669    * Already in table?
 670    */
 671   for (i = 0; i < MAXTARGETS; ++i) {
 672     if (targets[i] == hash)
 673       return;
 674   }
 675   /*
 676    * New target
 677    */
 678   memmove(&targets[RESERVEDTARGETS + 1],
 679           &targets[RESERVEDTARGETS], MAXTARGETS - RESERVEDTARGETS - 1);
 680   targets[RESERVEDTARGETS] = hash;
 681 }
 682
 683 /** Check whether \a sptr can send to or join \a target yet.
 684  * @param[in] sptr User trying to join a channel or send a message.
 685  * @param[in] target Target of the join or message.
 686  * @param[in] name Name of the target.
 687  * @param[in] created If non-zero, trying to join a new channel.
 688  * @return Non-zero if too many target changes; zero if okay to send.
 689  */
 690 int check_target_limit(struct Client *sptr, void *target, const char *name,
 691     int created)
 692 {
 693   unsigned char hash = hash_target((unsigned long) target);
 694   int            i;
 695   unsigned char* targets;
 696
 697   assert(0 != sptr);
 698   assert(cli_local(sptr));
 699   targets = cli_targets(sptr);
 700
 701   /* If user is invited to channel, give him/her a free target */
 702   if (IsChannelName(name) && IsInvited(sptr, target))
 703     return 0;
 704
 705   /*
 706    * Same target as last time?
 707    */
 708   if (targets[0] == hash)
 709     return 0;
 710   for (i = 1; i < MAXTARGETS; ++i) {
 711     if (targets[i] == hash) {
 712       memmove(&targets[1], &targets[0], i);
 713       targets[0] = hash;
 714       return 0;
 715     }
 716   }
 717   /*
 718    * New target
 719    */
 720   if (!created) {
 721     if (CurrentTime < cli_nexttarget(sptr)) {
 722       if (cli_nexttarget(sptr) - CurrentTime < TARGET_DELAY + 8) {
 723         /*
 724          * No server flooding
 725          */
 726         cli_nexttarget(sptr) += 2;
 727         send_reply(sptr, ERR_TARGETTOOFAST, name,
 728                    cli_nexttarget(sptr) - CurrentTime);
 729       }
 730       return 1;
 731     }
 732     else {
 733       cli_nexttarget(sptr) += TARGET_DELAY;
 734       if (cli_nexttarget(sptr) < CurrentTime - (TARGET_DELAY * (MAXTARGETS - 1)))
 735         cli_nexttarget(sptr) = CurrentTime - (TARGET_DELAY * (MAXTARGETS - 1));
 736     }
 737   }
 738   memmove(&targets[1], &targets[0], MAXTARGETS - 1);
 739   targets[0] = hash;
 740   return 0;
 741 }
 742
 743 /** Allows a channel operator to avoid target change checks when
 744  * sending messages to users on their channel.
 745  * @param[in] source User sending the message.
 746  * @param[in] nick Destination of the message.
 747  * @param[in] channel Name of channel being sent to.
 748  * @param[in] text Message to send.
 749  * @param[in] is_notice If non-zero, use CNOTICE instead of CPRIVMSG.
 750  */
 751 /* Added 971023 by Run. */
 752 int whisper(struct Client* source, const char* nick, const char* channel,
 753             const char* text, int is_notice)
 754 {
 755   struct Client*     dest;
 756   struct Channel*    chptr;
 757   struct Membership* membership;
 758
 759   assert(0 != source);
 760   assert(0 != nick);
 761   assert(0 != channel);
 762   assert(MyUser(source));
 763
 764   if (!(dest = FindUser(nick))) {
 765     return send_reply(source, ERR_NOSUCHNICK, nick);
 766   }
 767   if (!(chptr = FindChannel(channel))) {
 768     return send_reply(source, ERR_NOSUCHCHANNEL, channel);
 769   }
 770   /*
 771    * compare both users channel lists, instead of the channels user list
 772    * since the link is the same, this should be a little faster for channels
 773    * with a lot of users
 774    */
 775   for (membership = cli_user(source)->channel; membership; membership = membership->next_channel) {
 776     if (chptr == membership->channel)
 777       break;
 778   }
 779   if (0 == membership) {
 780     return send_reply(source, ERR_NOTONCHANNEL, chptr->chname);
 781   }
 782   if (!IsVoicedOrOpped(membership)) {
 783     return send_reply(source, ERR_VOICENEEDED, chptr->chname);
 784   }
 785   /*
 786    * lookup channel in destination
 787    */
 788   assert(0 != cli_user(dest));
 789   for (membership = cli_user(dest)->channel; membership; membership = membership->next_channel) {
 790     if (chptr == membership->channel)
 791       break;
 792   }
 793   if (0 == membership || IsZombie(membership)) {
 794     return send_reply(source, ERR_USERNOTINCHANNEL, cli_name(dest), chptr->chname);
 795   }
 796   if (is_silenced(source, dest))
 797     return 0;
 798
 799   if (cli_user(dest)->away)
 800     send_reply(source, RPL_AWAY, cli_name(dest), cli_user(dest)->away);
 801   if (is_notice)
 802     sendcmdto_one(source, CMD_NOTICE, dest, "%C :%s", dest, text);
 803   else
 804     sendcmdto_one(source, CMD_PRIVATE, dest, "%C :%s", dest, text);
 805   return 0;
 806 }
 807
 808
 809 /** Send a user mode change for \a cptr to neighboring servers.
 810  * @param[in] cptr User whose mode is changing.
 811  * @param[in] sptr Client who sent us the mode change message.
 812  * @param[in] old Prior set of user flags.
 813  * @param[in] prop If non-zero, also include FLAG_OPER.
 814  */
 815 void send_umode_out(struct Client *cptr, struct Client *sptr,
 816                     struct Flags *old, int prop)
 817 {
 818   int i;
 819   struct Client *acptr;
 820
 821   send_umode(NULL, sptr, old, prop ? SEND_UMODES : SEND_UMODES_BUT_OPER);
 822
 823   for (i = HighestFd; i >= 0; i--)
 824   {
 825     if ((acptr = LocalClientArray[i]) && IsServer(acptr) &&
 826         (acptr != cptr) && (acptr != sptr) && *umodeBuf)
 827       sendcmdto_one(sptr, CMD_MODE, acptr, "%s :%s", cli_name(sptr), umodeBuf);
 828   }
 829   if (cptr && MyUser(cptr))
 830     send_umode(cptr, sptr, old, ALL_UMODES);
 831 }
 832
 833
 834 /** Call \a fmt for each Client named in \a names.
 835  * @param[in] sptr Client requesting information.
 836  * @param[in] names Space-delimited list of nicknames.
 837  * @param[in] rpl Base reply string for messages.
 838  * @param[in] fmt Formatting callback function.
 839  */
 840 void send_user_info(struct Client* sptr, char* names, int rpl, InfoFormatter fmt)
 841 {
 842   char*          name;
 843   char*          p = 0;
 844   int            arg_count = 0;
 845   int            users_found = 0;
 846   struct Client* acptr;
 847   struct MsgBuf* mb;
 848
 849   assert(0 != sptr);
 850   assert(0 != names);
 851   assert(0 != fmt);
 852
 853   mb = msgq_make(sptr, rpl_str(rpl), cli_name(&me), cli_name(sptr));
 854
 855   for (name = ircd_strtok(&p, names, " "); name; name = ircd_strtok(&p, 0, " ")) {
 856     if ((acptr = FindUser(name))) {
 857       if (users_found++)
 858         msgq_append(0, mb, " ");
 859       (*fmt)(acptr, sptr, mb);
 860     }
 861     if (5 == ++arg_count)
 862       break;
 863   }
 864   send_buffer(sptr, mb, 0);
 865   msgq_clean(mb);
 866 }
 867
 868 /** Set \a flag on \a cptr and possibly hide the client's hostmask.
 869  * @param[in,out] cptr User who is getting a new flag.
 870  * @param[in] flag Some flag that affects host-hiding (FLAG_HIDDENHOST, FLAG_ACCOUNT).
 871  * @return Zero.
 872  */
 873 int
 874 hide_hostmask(struct Client *cptr, unsigned int flag)
 875 {
 876   struct Membership *chan;
 877
 878   switch (flag) {
 879   case FLAG_HIDDENHOST:
 880     /* Local users cannot set +x unless FEAT_HOST_HIDING is true. */
 881     if (MyConnect(cptr) && !feature_bool(FEAT_HOST_HIDING))
 882       return 0;
 883     break;
 884   case FLAG_ACCOUNT:
 885     /* Invalidate all bans against the user so we check them again */
 886     for (chan = (cli_user(cptr))->channel; chan;
 887          chan = chan->next_channel)
 888       ClearBanValid(chan);
 889     break;
 890   default:
 891     return 0;
 892   }
 893
 894   SetFlag(cptr, flag);
 895   if (!HasFlag(cptr, FLAG_HIDDENHOST) || !HasFlag(cptr, FLAG_ACCOUNT))
 896     return 0;
 897
 898   sendcmdto_common_channels_butone(cptr, CMD_QUIT, cptr, ":Registered");
 899   ircd_snprintf(0, cli_user(cptr)->host, HOSTLEN, "%s.%s",
 900                 cli_user(cptr)->account, feature_str(FEAT_HIDDEN_HOST));
 901
 902   /* ok, the client is now fully hidden, so let them know -- hikari */
 903   if (MyConnect(cptr))
 904    send_reply(cptr, RPL_HOSTHIDDEN, cli_user(cptr)->host);
 905
 906   /*
 907    * Go through all channels the client was on, rejoin him
 908    * and set the modes, if any
 909    */
 910   for (chan = cli_user(cptr)->channel; chan; chan = chan->next_channel)
 911   {
 912     if (IsZombie(chan))
 913       continue;
 914     /* Send a JOIN unless the user's join has been delayed. */
 915     if (!IsDelayedJoin(chan))
 916       sendcmdto_channel_butserv_butone(cptr, CMD_JOIN, chan->channel, cptr, 0,
 917                                          "%H", chan->channel);
 918     if (IsChanOp(chan) && HasVoice(chan))
 919       sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan->channel, cptr, 0,
 920                                        "%H +ov %C %C", chan->channel, cptr,
 921                                        cptr);
 922     else if (IsChanOp(chan) || HasVoice(chan))
 923       sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan->channel, cptr, 0,
 924         "%H +%c %C", chan->channel, IsChanOp(chan) ? 'o' : 'v', cptr);
 925   }
 926   return 0;
 927 }
 928
 929 /** Set a user's mode.  This function checks that \a cptr is trying to
 930  * set his own mode, prevents local users from setting inappropriate
 931  * modes through this function, and applies any other side effects of
 932  * a successful mode change.
 933  *
 934  * @param[in,out] cptr User setting someone's mode.
 935  * @param[in] sptr Client who sent the mode change message.
 936  * @param[in] parc Number of parameters in \a parv.
 937  * @param[in] parv Parameters to MODE.
 938  * @param[in] allow_modes ALLOWMODES_ANY for any mode, ALLOWMODES_DEFAULT for
 939  *                        only permitting legitimate default user modes.
 940  * @return Zero.
 941  */
 942 int set_user_mode(struct Client *cptr, struct Client *sptr, int parc,
 943                 char *parv[], int allow_modes)
 944 {
 945   char** p;
 946   char*  m;
 947   int what;
 948   int i;
 949   struct Flags setflags;
 950   unsigned int tmpmask = 0;
 951   int snomask_given = 0;
 952   char buf[BUFSIZE];
 953   int prop = 0;
 954   int do_host_hiding = 0;
 955   char* account = NULL;
 956
 957   what = MODE_ADD;
 958
 959   if (parc < 3)
 960   {
 961     m = buf;
 962     *m++ = '+';
 963     for (i = 0; i < USERMODELIST_SIZE; i++)
 964     {
 965       if (HasFlag(sptr, userModeList[i].flag) &&
 966           userModeList[i].flag != FLAG_ACCOUNT)
 967         *m++ = userModeList[i].c;
 968     }
 969     *m = '\0';
 970     send_reply(sptr, RPL_UMODEIS, buf);
 971     if (HasFlag(sptr, FLAG_SERVNOTICE) && MyConnect(sptr)
 972         && cli_snomask(sptr) !=
 973         (unsigned int)(IsOper(sptr) ? SNO_OPERDEFAULT : SNO_DEFAULT))
 974       send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr));
 975     return 0;
 976   }
 977
 978   /*
 979    * find flags already set for user
 980    * why not just copy them?
 981    */
 982   setflags = cli_flags(sptr);
 983
 984   if (MyConnect(sptr))
 985     tmpmask = cli_snomask(sptr);
 986
 987   /*
 988    * parse mode change string(s)
 989    */
 990   for (p = &parv[2]; *p && p<&parv[parc]; p++) {       /* p is changed in loop too */
 991     for (m = *p; *m; m++) {
 992       switch (*m) {
 993       case '+':
 994         what = MODE_ADD;
 995         break;
 996       case '-':
 997         what = MODE_DEL;
 998         break;
 999       case 's':
1000         if (*(p + 1) && is_snomask(*(p + 1))) {
1001           snomask_given = 1;
1002           tmpmask = umode_make_snomask(tmpmask, *++p, what);
1003           tmpmask &= (IsAnOper(sptr) ? SNO_ALL : SNO_USER);
1004         }
1005         else
1006           tmpmask = (what == MODE_ADD) ?
1007               (IsAnOper(sptr) ? SNO_OPERDEFAULT : SNO_DEFAULT) : 0;
1008         if (tmpmask)
1009           SetServNotice(sptr);
1010         else
1011           ClearServNotice(sptr);
1012         break;
1013       case 'w':
1014         if (what == MODE_ADD)
1015           SetWallops(sptr);
1016         else
1017           ClearWallops(sptr);
1018         break;
1019       case 'o':
1020         if (what == MODE_ADD)
1021           SetOper(sptr);
1022         else {
1023           ClrFlag(sptr, FLAG_OPER);
1024           ClrFlag(sptr, FLAG_LOCOP);
1025           if (MyConnect(sptr))
1026           {
1027             tmpmask = cli_snomask(sptr) & ~SNO_OPER;
1028             cli_handler(sptr) = CLIENT_HANDLER;
1029           }
1030         }
1031         break;
1032       case 'O':
1033         if (what == MODE_ADD)
1034           SetLocOp(sptr);
1035         else
1036         {
1037           ClrFlag(sptr, FLAG_OPER);
1038           ClrFlag(sptr, FLAG_LOCOP);
1039           if (MyConnect(sptr))
1040           {
1041             tmpmask = cli_snomask(sptr) & ~SNO_OPER;
1042             cli_handler(sptr) = CLIENT_HANDLER;
1043           }
1044         }
1045         break;
1046       case 'i':
1047         if (what == MODE_ADD)
1048           SetInvisible(sptr);
1049         else
1050           ClearInvisible(sptr);
1051         break;
1052       case 'd':
1053         if (what == MODE_ADD)
1054           SetDeaf(sptr);
1055         else
1056           ClearDeaf(sptr);
1057         break;
1058       case 'k':
1059         if (what == MODE_ADD)
1060           SetChannelService(sptr);
1061         else
1062           ClearChannelService(sptr);
1063         break;
1064       case 'g':
1065         if (what == MODE_ADD)
1066           SetDebug(sptr);
1067         else
1068           ClearDebug(sptr);
1069         break;
1070       case 'x':
1071         if (what == MODE_ADD)
1072           do_host_hiding = 1;
1073         break;
1074       case 'r':
1075         if (what == MODE_ADD) {
1076           account = *(++p);
1077           SetAccount(sptr);
1078         }
1079         /* There is no -r */
1080         break;
1081       default:
1082         send_reply(sptr, ERR_UMODEUNKNOWNFLAG, *m);
1083         break;
1084       }
1085     }
1086   }
1087   /*
1088    * Evaluate rules for new user mode
1089    * Stop users making themselves operators too easily:
1090    */
1091   if (!IsServer(cptr))
1092   {
1093     if (!FlagHas(&setflags, FLAG_OPER) && IsOper(sptr))
1094       ClearOper(sptr);
1095     if (!FlagHas(&setflags, FLAG_LOCOP) && IsLocOp(sptr))
1096       ClearLocOp(sptr);
1097     if (!FlagHas(&setflags, FLAG_ACCOUNT) && IsAccount(sptr))
1098       ClrFlag(sptr, FLAG_ACCOUNT);
1099     /*
1100      * new umode; servers can set it, local users cannot;
1101      * prevents users from /kick'ing or /mode -o'ing
1102      */
1103     if (!FlagHas(&setflags, FLAG_CHSERV))
1104       ClearChannelService(sptr);
1105     /*
1106      * only send wallops to opers
1107      */
1108     if (feature_bool(FEAT_WALLOPS_OPER_ONLY) && !IsAnOper(sptr) &&
1109         !FlagHas(&setflags, FLAG_WALLOP))
1110       ClearWallops(sptr);
1111     if (feature_bool(FEAT_HIS_SNOTICES_OPER_ONLY) && MyConnect(sptr) &&
1112         !IsAnOper(sptr) && !FlagHas(&setflags, FLAG_SERVNOTICE))
1113     {
1114       ClearServNotice(sptr);
1115       set_snomask(sptr, 0, SNO_SET);
1116     }
1117     if (feature_bool(FEAT_HIS_DEBUG_OPER_ONLY) &&
1118         !IsAnOper(sptr) && !FlagHas(&setflags, FLAG_DEBUG))
1119       ClearDebug(sptr);
1120   }
1121   if (MyConnect(sptr))
1122   {
1123     if ((FlagHas(&setflags, FLAG_OPER) || FlagHas(&setflags, FLAG_LOCOP)) &&
1124         !IsAnOper(sptr))
1125       det_confs_butmask(sptr, CONF_CLIENT & ~CONF_OPERATOR);
1126
1127     if (SendServNotice(sptr))
1128     {
1129       if (tmpmask != cli_snomask(sptr))
1130         set_snomask(sptr, tmpmask, SNO_SET);
1131       if (cli_snomask(sptr) && snomask_given)
1132         send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr));
1133     }
1134     else
1135       set_snomask(sptr, 0, SNO_SET);
1136   }
1137   /*
1138    * Compare new flags with old flags and send string which
1139    * will cause servers to update correctly.
1140    */
1141   if (!FlagHas(&setflags, FLAG_OPER) && IsOper(sptr))
1142   {
1143     /* user now oper */
1144     ++UserStats.opers;
1145     client_set_privs(sptr, NULL); /* may set propagate privilege */
1146   }
1147   /* remember propagate privilege setting */
1148   if (HasPriv(sptr, PRIV_PROPAGATE))
1149     prop = 1;
1150   if (FlagHas(&setflags, FLAG_OPER) && !IsOper(sptr))
1151   {
1152     /* user no longer oper */
1153     assert(UserStats.opers > 0);
1154     --UserStats.opers;
1155     client_set_privs(sptr, NULL); /* will clear propagate privilege */
1156   }
1157   if (FlagHas(&setflags, FLAG_INVISIBLE) && !IsInvisible(sptr)) {
1158     assert(UserStats.inv_clients > 0);
1159     --UserStats.inv_clients;
1160   }
1161   if (!FlagHas(&setflags, FLAG_INVISIBLE) && IsInvisible(sptr))
1162     ++UserStats.inv_clients;
1163   if (!FlagHas(&setflags, FLAG_ACCOUNT) && IsAccount(sptr)) {
1164       int len = ACCOUNTLEN;
1165       char *ts;
1166       if ((ts = strchr(account, ':'))) {
1167         len = (ts++) - account;
1168         cli_user(sptr)->acc_create = atoi(ts);
1169         Debug((DEBUG_DEBUG, "Received timestamped account in user mode; "
1170               "account \"%s\", timestamp %Tu", account,
1171               cli_user(sptr)->acc_create));
1172       }
1173       ircd_strncpy(cli_user(sptr)->account, account, len);
1174   }
1175   if (!FlagHas(&setflags, FLAG_HIDDENHOST) && do_host_hiding && allow_modes != ALLOWMODES_DEFAULT)
1176     hide_hostmask(sptr, FLAG_HIDDENHOST);
1177   if (IsRegistered(sptr))
1178     send_umode_out(cptr, sptr, &setflags, prop);
1179
1180   assert(UserStats.opers <= UserStats.clients + UserStats.unknowns);
1181   assert(UserStats.inv_clients <= UserStats.clients + UserStats.unknowns);
1182   return 0;
1183 }
1184
1185 /** Build a mode string to describe modes for \a cptr.
1186  * @param[in] cptr Some user.
1187  * @return Pointer to a static buffer.
1188  */
1189 char *umode_str(struct Client *cptr)
1190 {
1191   /* Maximum string size: "owidgrx\0" */
1192   char *m = umodeBuf;
1193   int i;
1194   struct Flags c_flags = cli_flags(cptr);
1195
1196   if (!HasPriv(cptr, PRIV_PROPAGATE))
1197     FlagClr(&c_flags, FLAG_OPER);
1198
1199   for (i = 0; i < USERMODELIST_SIZE; ++i)
1200   {
1201     if (FlagHas(&c_flags, userModeList[i].flag) &&
1202         userModeList[i].flag >= FLAG_GLOBAL_UMODES)
1203       *m++ = userModeList[i].c;
1204   }
1205
1206   if (IsAccount(cptr))
1207   {
1208     char* t = cli_user(cptr)->account;
1209
1210     *m++ = ' ';
1211     while ((*m++ = *t++))
1212       ; /* Empty loop */
1213
1214     if (cli_user(cptr)->acc_create) {
1215       char nbuf[20];
1216       Debug((DEBUG_DEBUG, "Sending timestamped account in user mode for "
1217              "account \"%s\"; timestamp %Tu", cli_user(cptr)->account,
1218              cli_user(cptr)->acc_create));
1219       ircd_snprintf(0, t = nbuf, sizeof(nbuf), ":%Tu",
1220                     cli_user(cptr)->acc_create);
1221       m--; /* back up over previous nul-termination */
1222       while ((*m++ = *t++))
1223         ; /* Empty loop */
1224     }
1225   }
1226
1227   *m = '\0';
1228
1229   return umodeBuf;                /* Note: static buffer, gets
1230                                    overwritten by send_umode() */
1231 }
1232
1233 /** Send a mode change string for \a sptr to \a cptr.
1234  * @param[in] cptr Destination of mode change message.
1235  * @param[in] sptr User whose mode has changed.
1236  * @param[in] old Pre-change set of modes for \a sptr.
1237  * @param[in] sendset One of ALL_UMODES, SEND_UMODES_BUT_OPER,
1238  * SEND_UMODES, to select which changed user modes to send.
1239  */
1240 void send_umode(struct Client *cptr, struct Client *sptr, struct Flags *old,
1241                 int sendset)
1242 {
1243   int i;
1244   int flag;
1245   char *m;
1246   int what = MODE_NULL;
1247
1248   /*
1249    * Build a string in umodeBuf to represent the change in the user's
1250    * mode between the new (cli_flags(sptr)) and 'old', but skipping
1251    * the modes indicated by sendset.
1252    */
1253   m = umodeBuf;
1254   *m = '\0';
1255   for (i = 0; i < USERMODELIST_SIZE; ++i)
1256   {
1257     flag = userModeList[i].flag;
1258     if (FlagHas(old, flag)
1259         == HasFlag(sptr, flag))
1260       continue;
1261     switch (sendset)
1262     {
1263     case ALL_UMODES:
1264       break;
1265     case SEND_UMODES_BUT_OPER:
1266       if (flag == FLAG_OPER)
1267         continue;
1268       /* and fall through */
1269     case SEND_UMODES:
1270       if (flag < FLAG_GLOBAL_UMODES)
1271         continue;
1272       break;
1273     }
1274     if (FlagHas(old, flag))
1275     {
1276       if (what == MODE_DEL)
1277         *m++ = userModeList[i].c;
1278       else
1279       {
1280         what = MODE_DEL;
1281         *m++ = '-';
1282         *m++ = userModeList[i].c;
1283       }
1284     }
1285     else /* !FlagHas(old, flag) */
1286     {
1287       if (what == MODE_ADD)
1288         *m++ = userModeList[i].c;
1289       else
1290       {
1291         what = MODE_ADD;
1292         *m++ = '+';
1293         *m++ = userModeList[i].c;
1294       }
1295     }
1296   }
1297   *m = '\0';
1298   if (*umodeBuf && cptr)
1299     sendcmdto_one(sptr, CMD_MODE, cptr, "%s :%s", cli_name(sptr), umodeBuf);
1300 }
1301
1302 /**
1303  * Check to see if this resembles a sno_mask.  It is if 1) there is
1304  * at least one digit and 2) The first digit occurs before the first
1305  * alphabetic character.
1306  * @param[in] word Word to check for sno_mask-ness.
1307  * @return Non-zero if \a word looks like a server notice mask; zero if not.
1308  */
1309 int is_snomask(char *word)
1310 {
1311   if (word)
1312   {
1313     for (; *word; word++)
1314       if (IsDigit(*word))
1315         return 1;
1316       else if (IsAlpha(*word))
1317         return 0;
1318   }
1319   return 0;
1320 }
1321
1322 /** Update snomask \a oldmask according to \a arg and \a what.
1323  * @param[in] oldmask Original user mask.
1324  * @param[in] arg Update string (either a number or '+'/'-' followed by a number).
1325  * @param[in] what MODE_ADD if adding the mask.
1326  * @return New value of service notice mask.
1327  */
1328 unsigned int umode_make_snomask(unsigned int oldmask, char *arg, int what)
1329 {
1330   unsigned int sno_what;
1331   unsigned int newmask;
1332   if (*arg == '+')
1333   {
1334     arg++;
1335     if (what == MODE_ADD)
1336       sno_what = SNO_ADD;
1337     else
1338       sno_what = SNO_DEL;
1339   }
1340   else if (*arg == '-')
1341   {
1342     arg++;
1343     if (what == MODE_ADD)
1344       sno_what = SNO_DEL;
1345     else
1346       sno_what = SNO_ADD;
1347   }
1348   else
1349     sno_what = (what == MODE_ADD) ? SNO_SET : SNO_DEL;
1350   /* pity we don't have strtoul everywhere */
1351   newmask = (unsigned int)atoi(arg);
1352   if (sno_what == SNO_DEL)
1353     newmask = oldmask & ~newmask;
1354   else if (sno_what == SNO_ADD)
1355     newmask |= oldmask;
1356   return newmask;
1357 }
1358
1359 /** Remove \a cptr from the singly linked list \a list.
1360  * @param[in] cptr Client to remove from list.
1361  * @param[in,out] list Pointer to head of list containing \a cptr.
1362  */
1363 static void delfrom_list(struct Client *cptr, struct SLink **list)
1364 {
1365   struct SLink* tmp;
1366   struct SLink* prv = NULL;
1367
1368   for (tmp = *list; tmp; tmp = tmp->next) {
1369     if (tmp->value.cptr == cptr) {
1370       if (prv)
1371         prv->next = tmp->next;
1372       else
1373         *list = tmp->next;
1374       free_link(tmp);
1375       break;
1376     }
1377     prv = tmp;
1378   }
1379 }
1380
1381 /** Set \a cptr's server notice mask, according to \a what.
1382  * @param[in,out] cptr Client whose snomask is updating.
1383  * @param[in] newmask Base value for new snomask.
1384  * @param[in] what One of SNO_ADD, SNO_DEL, SNO_SET, to choose operation.
1385  */
1386 void set_snomask(struct Client *cptr, unsigned int newmask, int what)
1387 {
1388   unsigned int oldmask, diffmask;        /* unsigned please */
1389   int i;
1390   struct SLink *tmp;
1391
1392   oldmask = cli_snomask(cptr);
1393
1394   if (what == SNO_ADD)
1395     newmask |= oldmask;
1396   else if (what == SNO_DEL)
1397     newmask = oldmask & ~newmask;
1398   else if (what != SNO_SET)        /* absolute set, no math needed */
1399     sendto_opmask_butone(0, SNO_OLDSNO, "setsnomask called with %d ?!", what);
1400
1401   newmask &= (IsAnOper(cptr) ? SNO_ALL : SNO_USER);
1402
1403   diffmask = oldmask ^ newmask;
1404
1405   for (i = 0; diffmask >> i; i++) {
1406     if (((diffmask >> i) & 1))
1407     {
1408       if (((newmask >> i) & 1))
1409       {
1410         tmp = make_link();
1411         tmp->next = opsarray[i];
1412         tmp->value.cptr = cptr;
1413         opsarray[i] = tmp;
1414       }
1415       else
1416         /* not real portable :( */
1417         delfrom_list(cptr, &opsarray[i]);
1418     }
1419   }
1420   cli_snomask(cptr) = newmask;
1421 }
1422
1423 /** Check whether \a sptr is allowed to send a message to \a acptr.
1424  * If \a sptr is a remote user, it means some server has an outdated
1425  * SILENCE list for \a acptr, so send the missing SILENCE mask(s) back
1426  * in the direction of \a sptr.  Skip the check if \a sptr is a server.
1427  * @param[in] sptr Client trying to send a message.
1428  * @param[in] acptr Destination of message.
1429  * @return Non-zero if \a sptr is SILENCEd by \a acptr, zero if not.
1430  */
1431 int is_silenced(struct Client *sptr, struct Client *acptr)
1432 {
1433   struct Ban *found;
1434   struct User *user;
1435   size_t buf_used, slen;
1436   char buf[BUFSIZE];
1437
1438   if (IsServer(sptr) || !(user = cli_user(acptr))
1439       || !(found = find_ban(sptr, user->silence)))
1440     return 0;
1441   assert(!(found->flags & BAN_EXCEPTION));
1442   if (!MyConnect(sptr)) {
1443     /* Buffer positive silence to send back. */
1444     buf_used = strlen(found->banstr);
1445     memcpy(buf, found->banstr, buf_used);
1446     /* Add exceptions to buffer. */
1447     for (found = user->silence; found; found = found->next) {
1448       if (!(found->flags & BAN_EXCEPTION))
1449         continue;
1450       slen = strlen(found->banstr);
1451       if (buf_used + slen + 4 > 400) {
1452         buf[buf_used] = '\0';
1453         sendcmdto_one(acptr, CMD_SILENCE, cli_from(sptr), "%C %s", sptr, buf);
1454         buf_used = 0;
1455       }
1456       if (buf_used)
1457         buf[buf_used++] = ',';
1458       buf[buf_used++] = '+';
1459       buf[buf_used++] = '~';
1460       memcpy(buf + buf_used, found->banstr, slen);
1461       buf_used += slen;
1462     }
1463     /* Flush silence buffer. */
1464     if (buf_used) {
1465       buf[buf_used] = '\0';
1466       sendcmdto_one(acptr, CMD_SILENCE, cli_from(sptr), "%C %s", sptr, buf);
1467       buf_used = 0;
1468     }
1469   }
1470   return 1;
1471 }
1472
1473 /** Send RPL_ISUPPORT lines to \a cptr.
1474  * @param[in] cptr Client to send ISUPPORT to.
1475  * @return Zero.
1476  */
1477 int
1478 send_supported(struct Client *cptr)
1479 {
1480   char featurebuf[512];
1481
1482   ircd_snprintf(0, featurebuf, sizeof(featurebuf), FEATURES1, FEATURESVALUES1);
1483   send_reply(cptr, RPL_ISUPPORT, featurebuf);
1484   ircd_snprintf(0, featurebuf, sizeof(featurebuf), FEATURES2, FEATURESVALUES2);
1485   send_reply(cptr, RPL_ISUPPORT, featurebuf);
1486
1487   return 0; /* convenience return, if it's ever needed */
1488 }
1489
1490 /* vim: shiftwidth=2
1491  */