fixed FAKEIDENT handling
[ircu2.10.12-pk.git] / 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: s_user.c 1864 2008-03-15 05:33:22Z entrope $
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     if (user->lastmsg)
114       MyFree(user->lastmsg);
115     /*
116      * sanity check
117      */
118     assert(0 == user->joined);
119     assert(0 == user->invited);
120     assert(0 == user->channel);
121
122     MyFree(user);
123     assert(userCount>0);
124     --userCount;
125   }
126 }
127
128 /** Find number of User structs allocated and memory used by them.
129  * @param[out] count_out Receives number of User structs allocated.
130  * @param[out] bytes_out Receives number of bytes used by User structs.
131  */
132 void user_count_memory(size_t* count_out, size_t* bytes_out)
133 {
134   assert(0 != count_out);
135   assert(0 != bytes_out);
136   *count_out = userCount;
137   *bytes_out = userCount * sizeof(struct User);
138 }
139
140
141 /** Find the next client (starting at \a next) with a name that matches \a ch.
142  * Normal usage loop is:
143  * for (x = client; x = next_client(x,mask); x = x->next)
144  *     HandleMatchingClient;
145  *
146  * @param[in] next First client to check.
147  * @param[in] ch Name mask to check against.
148  * @return Next matching client found, or NULL if none.
149  */
150 struct Client *next_client(struct Client *next, const char* ch)
151 {
152   struct Client *tmp = next;
153
154   if (!tmp)
155     return NULL;
156
157   next = FindClient(ch);
158   next = next ? next : tmp;
159   if (cli_prev(tmp) == next)
160     return NULL;
161   if (next != tmp)
162     return next;
163   for (; next; next = cli_next(next))
164     if (!match(ch, cli_name(next)))
165       break;
166   return next;
167 }
168
169 /** Find the destination server for a command, and forward it if that is not us.
170  *
171  * \a server may be a nickname, server name, server mask (if \a from
172  * is a local user) or server numnick (if \a is a server or remote
173  * user).
174  *
175  * @param[in] from Client that sent the command to us.
176  * @param[in] cmd Long-form command text.
177  * @param[in] tok Token-form command text.
178  * @param[in] one Client that originated the command (ignored).
179  * @param[in] MustBeOper If non-zero and \a from is not an operator, return HUNTED_NOSUCH.
180  * @param[in] pattern Format string of arguments to command.
181  * @param[in] server Index of target name or mask in \a parv.
182  * @param[in] parc Number of valid elements in \a parv (must be less than 9).
183  * @param[in] parv Array of arguments to command.
184  * @return One of HUNTED_ISME, HUNTED_NOSUCH or HUNTED_PASS.
185  */
186 int hunt_server_cmd(struct Client *from, const char *cmd, const char *tok,
187                     struct Client *one, int MustBeOper, const char *pattern,
188                     int server, int parc, char *parv[])
189 {
190   struct Client *acptr;
191   char *to;
192
193   /* Assume it's me, if no server or an unregistered client */
194   if (parc <= server || EmptyString((to = parv[server])) || IsUnknown(from))
195     return (HUNTED_ISME);
196
197   if (MustBeOper && !IsPrivileged(from))
198   {
199     send_reply(from, ERR_NOPRIVILEGES);
200     return HUNTED_NOSUCH;
201   }
202
203   /* Make sure it's a server */
204   if (MyUser(from)) {
205     /* Make sure it's a server */
206     if (!strchr(to, '*')) {
207       if (0 == (acptr = FindClient(to))) {
208         send_reply(from, ERR_NOSUCHSERVER, to);
209         return HUNTED_NOSUCH;
210       }
211
212       if (cli_user(acptr))
213         acptr = cli_user(acptr)->server;
214     } else if (!(acptr = find_match_server(to))) {
215       send_reply(from, ERR_NOSUCHSERVER, to);
216       return (HUNTED_NOSUCH);
217     }
218   } else if (!(acptr = FindNServer(to))) {
219     send_reply(from, SND_EXPLICIT | ERR_NOSUCHSERVER, "* :Server has disconnected");
220     return (HUNTED_NOSUCH);        /* Server broke off in the meantime */
221   }
222
223   if (IsMe(acptr))
224     return (HUNTED_ISME);
225
226   if (MustBeOper && !IsPrivileged(from)) {
227     send_reply(from, ERR_NOPRIVILEGES);
228     return HUNTED_NOSUCH;
229   }
230
231   /* assert(!IsServer(from)); */
232
233   parv[server] = (char *) acptr; /* HACK! HACK! HACK! ARGH! */
234
235   sendcmdto_one(from, cmd, tok, acptr, pattern, parv[1], parv[2], parv[3],
236                 parv[4], parv[5], parv[6], parv[7], parv[8]);
237
238   return (HUNTED_PASS);
239 }
240
241 /** Find the destination server for a command, and forward it (as a
242  * high-priority command) if that is not us.
243  *
244  * \a server may be a nickname, server name, server mask (if \a from
245  * is a local user) or server numnick (if \a is a server or remote
246  * user).
247  * Unlike hunt_server_cmd(), this appends the message to the
248  * high-priority message queue for the destination server.
249  *
250  * @param[in] from Client that sent the command to us.
251  * @param[in] cmd Long-form command text.
252  * @param[in] tok Token-form command text.
253  * @param[in] one Client that originated the command (ignored).
254  * @param[in] MustBeOper If non-zero and \a from is not an operator, return HUNTED_NOSUCH.
255  * @param[in] pattern Format string of arguments to command.
256  * @param[in] server Index of target name or mask in \a parv.
257  * @param[in] parc Number of valid elements in \a parv (must be less than 9).
258  * @param[in] parv Array of arguments to command.
259  * @return One of HUNTED_ISME, HUNTED_NOSUCH or HUNTED_PASS.
260  */
261 int hunt_server_prio_cmd(struct Client *from, const char *cmd, const char *tok,
262                          struct Client *one, int MustBeOper,
263                          const char *pattern, int server, int parc,
264                          char *parv[])
265 {
266   struct Client *acptr;
267   char *to;
268
269   /* Assume it's me, if no server or an unregistered client */
270   if (parc <= server || EmptyString((to = parv[server])) || IsUnknown(from))
271     return (HUNTED_ISME);
272
273   /* Make sure it's a server */
274   if (MyUser(from)) {
275     /* Make sure it's a server */
276     if (!strchr(to, '*')) {
277       if (0 == (acptr = FindClient(to))) {
278         send_reply(from, ERR_NOSUCHSERVER, to);
279         return HUNTED_NOSUCH;
280       }
281
282       if (cli_user(acptr))
283         acptr = cli_user(acptr)->server;
284     } else if (!(acptr = find_match_server(to))) {
285       send_reply(from, ERR_NOSUCHSERVER, to);
286       return (HUNTED_NOSUCH);
287     }
288   } else if (!(acptr = FindNServer(to)))
289     return (HUNTED_NOSUCH);        /* Server broke off in the meantime */
290
291   if (IsMe(acptr))
292     return (HUNTED_ISME);
293
294   if (MustBeOper && !IsPrivileged(from)) {
295     send_reply(from, ERR_NOPRIVILEGES);
296     return HUNTED_NOSUCH;
297   }
298
299   /* assert(!IsServer(from)); SETTIME to particular destinations permitted */
300
301   parv[server] = (char *) acptr; /* HACK! HACK! HACK! ARGH! */
302
303   sendcmdto_prio_one(from, cmd, tok, acptr, pattern, parv[1], parv[2], parv[3],
304                      parv[4], parv[5], parv[6], parv[7], parv[8]);
305
306   return (HUNTED_PASS);
307 }
308
309 /* Helper function for register_user that splits up the parameters of the
310  * default user modes and sets them on the user.
311  */
312 static void set_initial_user_modes(struct Client *cptr) {
313   char **umodev;
314   int i, num, l, offset;
315   char *tmpstr = (char*)client_get_default_umode(cptr);
316   char *back;
317
318   if(!tmpstr) return;
319   tmpstr = strdup(tmpstr);
320
321   /* \tmpstr may have multiple parameters and \set_user_mode needs them
322    * to be split up. We just copy the default string and then replace the
323    * spaces with \0 to split the strings up.
324    */
325   num = 0;
326   for(i = 0; tmpstr[i]; ++i) {
327     if(tmpstr[i] == ' ') {
328       tmpstr[i] = 0;
329       ++num;
330     }
331   }
332
333   umodev = MyMalloc((6 + num) * sizeof(char*));
334   memset(umodev, 0, (6 + num) * sizeof(char*));
335
336   back = tmpstr;
337   offset = 0;
338   ++num;
339   for(i = 0; i < num; ++i) {
340     for(l = 0; back[l]; ++l) /* do nothing */;
341     /* Ignore empty parameters. */
342     if(l > 0) umodev[2 + i + offset] = back;
343     else --offset;
344     back = back + l + 1;
345   }
346
347   if(num + offset > 0)
348     set_user_mode(&me, cptr, 2 + num + offset, umodev, ALLOWMODES_WITHSECSERV);
349   MyFree(umodev);
350   MyFree(tmpstr);
351 }
352
353 /*
354  * register_user
355  *
356  * This function is called when both NICK and USER messages
357  * have been accepted for the client, in whatever order. Only
358  * after this the USER message is propagated.
359  *
360  * NICK's must be propagated at once when received, although
361  * it would be better to delay them too until full info is
362  * available. Doing it is not so simple though, would have
363  * to implement the following:
364  *
365  * 1) user telnets in and gives only "NICK foobar" and waits
366  * 2) another user far away logs in normally with the nick
367  *    "foobar" (quite legal, as this server didn't propagate it).
368  * 3) now this server gets nick "foobar" from outside, but
369  *    has already the same defined locally. Current server
370  *    would just issue "KILL foobar" to clean out dups. But,
371  *    this is not fair. It should actually request another
372  *    nick from local user or kill him/her...
373  */
374 /** Finish registering a user who has sent both NICK and USER.
375  * For local connections, possibly check IAuth; make sure there is a
376  * matching Client config block; clean the username field; check
377  * K/k-lines; check for "hacked" looking usernames; assign a numnick;
378  * and send greeting (WELCOME, ISUPPORT, MOTD, etc).
379  * For all connections, update the invisible user and operator counts;
380  * run IPcheck against their address; and forward the NICK.
381  *
382  * @param[in] cptr Client who introduced the user.
383  * @param[in,out] sptr Client who has been fully introduced.
384  * @return Zero or CPTR_KILLED.
385  */
386 int register_user(struct Client *cptr, struct Client *sptr)
387 {
388   char*            parv[4];
389   char*            tmpstr;
390   struct User*     user = cli_user(sptr);
391   char             ip_base64[25];
392
393   user->last = CurrentTime;
394   parv[0] = cli_name(sptr);
395   parv[1] = parv[2] = NULL;
396
397   if (MyConnect(sptr))
398   {
399     assert(cptr == sptr);
400
401     Count_unknownbecomesclient(sptr, UserStats);
402
403     /*
404      * Set user's initial modes
405      */
406     set_initial_user_modes(sptr);
407
408     SetUser(sptr);
409     if(MyConnect(sptr) && cli_socket(sptr).ssl)
410       SetSSL(sptr);
411
412     cli_handler(sptr) = CLIENT_HANDLER;
413     SetLocalNumNick(sptr);
414     send_reply(sptr,
415                RPL_WELCOME,
416                feature_str(FEAT_NETWORK),
417                feature_str(FEAT_PROVIDER) ? " via " : "",
418                feature_str(FEAT_PROVIDER) ? feature_str(FEAT_PROVIDER) : "",
419                cli_name(sptr));
420     /*
421      * This is a duplicate of the NOTICE but see below...
422      */
423     send_reply(sptr, RPL_YOURHOST, cli_name(&me), version);
424     send_reply(sptr, RPL_CREATED, creation);
425     send_reply(sptr, RPL_MYINFO, cli_name(&me), version, infousermodes,
426                infochanmodes, infochanmodeswithparams);
427     send_supported(sptr);
428
429     if(IsSSL(sptr))
430       sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :You are connected to %s with %s", sptr,
431                     cli_name(&me), ssl_cipherstr(cli_socket(sptr).ssl));
432
433     m_lusers(sptr, sptr, 1, parv);
434     update_load();
435     motd_signon(sptr);
436     if (cli_snomask(sptr) & SNO_NOISY)
437       set_snomask(sptr, cli_snomask(sptr) & SNO_NOISY, SNO_ADD);
438     if (feature_bool(FEAT_CONNEXIT_NOTICES))
439       sendto_opmask_butone(0, SNO_CONNEXIT,
440                            "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s%s>",
441                            cli_name(sptr), user->username, user->host,
442                            cli_sock_ip(sptr), get_client_class(sptr),
443                            cli_info(sptr), NumNick(cptr) /* two %s's */);
444     IPcheck_connect_succeeded(sptr);
445   }
446   else {
447     struct Client *acptr = user->server;
448
449     if (cli_from(acptr) != cli_from(sptr))
450     {
451       sendcmdto_one(&me, CMD_KILL, cptr, "%C :%s (%s != %s[%s])",
452                     sptr, cli_name(&me), cli_name(user->server), cli_name(cli_from(acptr)),
453                     cli_sockhost(cli_from(acptr)));
454       SetFlag(sptr, FLAG_KILLED);
455       return exit_client(cptr, sptr, &me, "NICK server wrong direction");
456     }
457     else if (HasFlag(acptr, FLAG_TS8))
458       SetFlag(sptr, FLAG_TS8);
459
460     /*
461      * Check to see if this user is being propagated
462      * as part of a net.burst, or is using protocol 9.
463      * FIXME: This can be sped up - its stupid to check it for
464      * every NICK message in a burst again  --Run.
465      */
466     for (; acptr != &me; acptr = cli_serv(acptr)->up)
467     {
468       if (IsBurst(acptr) || Protocol(acptr) < 10)
469         break;
470     }
471     if (!IPcheck_remote_connect(sptr, (acptr != &me)))
472     {
473       /*
474        * We ran out of bits to count this
475        */
476       sendcmdto_one(&me, CMD_KILL, sptr, "%C :%s (Too many connections from your host -- Ghost)",
477                     sptr, cli_name(&me));
478       return exit_client(cptr, sptr, &me,"Too many connections from your host -- throttled");
479     }
480     SetUser(sptr);
481   }
482
483   /* If they get both +x and an account during registration, hide
484    * their hostmask here.  Calling hide_hostmask() from IAuth's
485    * account assignment causes a numeric reply during registration.
486    */
487   if (HasHiddenHost(sptr))
488     hide_hostmask(sptr, FLAG_HIDDENHOST);
489   if (IsInvisible(sptr))
490     ++UserStats.inv_clients;
491   if (IsOper(sptr))
492     ++UserStats.opers;
493   if (MyUser(sptr))
494   {
495     if(IsOper(sptr)) {
496       FlagSet(&cli_confs(sptr)->value.aconf->conn_class->privs_dirty, PRIV_PROPAGATE);
497       client_set_privs(sptr, cli_confs(sptr)->value.aconf);
498       cli_handler(sptr) = OPER_HANDLER;
499     }
500     else
501       client_set_uprivs(sptr, cli_confs(sptr)->value.aconf);
502   }
503   if (MyUser(sptr) && HasPriv(sptr, PRIV_SEE_IDLETIME))
504     SetSeeIdletime(sptr);
505
506   tmpstr = umode_str(sptr);
507   /* Send full IP address to IPv6-grokking servers. */
508   sendcmdto_flag_serv_butone(user->server, CMD_NICK, cptr,
509                              FLAG_IPV6, FLAG_LAST_FLAG,
510                              "%s %d %Tu %s %s %s%s%s%s %s%s :%s",
511                              cli_name(sptr), cli_hopcount(sptr) + 1,
512                              cli_lastnick(sptr),
513                              user->username, user->realhost,
514                              *tmpstr ? "+" : "", tmpstr, *tmpstr ? " " : "",
515                              iptobase64(ip_base64, &cli_ip(sptr), sizeof(ip_base64), 1),
516                              NumNick(sptr), cli_info(sptr));
517   /* Send fake IPv6 addresses to pre-IPv6 servers. */
518   sendcmdto_flag_serv_butone(user->server, CMD_NICK, cptr,
519                              FLAG_LAST_FLAG, FLAG_IPV6,
520                              "%s %d %Tu %s %s %s%s%s%s %s%s :%s",
521                              cli_name(sptr), cli_hopcount(sptr) + 1,
522                              cli_lastnick(sptr),
523                              user->username, user->realhost,
524                              *tmpstr ? "+" : "", tmpstr, *tmpstr ? " " : "",
525                              iptobase64(ip_base64, &cli_ip(sptr), sizeof(ip_base64), 0),
526                              NumNick(sptr), cli_info(sptr));
527
528   /* Send user mode to client */
529   if (MyUser(sptr))
530   {
531     static struct Flags flags; /* automatically initialized to zeros */
532     /* To avoid sending +r to the client due to auth-on-connect, set
533      * the "old" FLAG_ACCOUNT bit to match the client's value.
534      */
535     if (IsAccount(cptr))
536       FlagSet(&flags, FLAG_ACCOUNT);
537     else
538       FlagClr(&flags, FLAG_ACCOUNT);
539
540     if(IsOper(sptr)) {
541       send_reply(sptr, RPL_YOUREOPER);
542       sendto_opmask_butone(0, SNO_OLDSNO, "%s (%s@%s) is now operator (%c)",
543                            cli_name(sptr), cli_user(sptr)->username, cli_sockhost(sptr),
544                            IsOper(sptr) ? 'O' : 'o');
545       log_write(LS_OPER, L_INFO, 0, "OPER (<OOC>) by (%#C)", sptr);
546     }
547     
548     if(*cli_connclass(sptr)) 
549         sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Your connection class is: %s", sptr, cli_connclass(sptr));
550     else
551         sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Your connection class is: %s", sptr, get_client_class(sptr));
552     if(HasPriv(sptr, PRIV_CHAN_LIMIT))
553       sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :You have no channel number limitation.", sptr);
554     else {
555         unsigned int maxchan = cli_confs(sptr)->value.aconf ? ConfMaxChannels(cli_confs(sptr)->value.aconf): feature_int(FEAT_MAXCHANNELSPERUSER);
556         if(sptr -> maxchans > 0) 
557             maxchan = sptr->maxchans;
558       sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :You may join %d channels.", sptr, maxchan);
559     }
560
561     send_umode(cptr, sptr, &flags, ALL_UMODES, 0);
562     if ((cli_snomask(sptr) != SNO_DEFAULT) && HasFlag(sptr, FLAG_SERVNOTICE))
563       send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr));
564   }
565   return 0;
566 }
567
568 /** List of user mode characters. */
569 static const struct UserMode {
570   unsigned int flag; /**< User mode constant. */
571   char         c;    /**< Character corresponding to the mode. */
572 } userModeList[] = {
573   { FLAG_OPER,        'o' },
574   { FLAG_LOCOP,       'O' },
575   { FLAG_INVISIBLE,   'i' },
576   { FLAG_WALLOP,      'w' },
577   { FLAG_SERVNOTICE,  's' },
578   { FLAG_DEAF,        'd' },
579   { FLAG_CHSERV,      'k' },
580   { FLAG_DEBUG,       'g' },
581   { FLAG_ACCOUNT,     'r' },
582   { FLAG_FAKEHOST,    'f' },
583   { FLAG_NOCHAN,      'n' },
584   { FLAG_NOIDLE,      'I' },
585   { FLAG_XTRAOP,      'X' },
586   { FLAG_NETSERV,     'S' },
587   { FLAG_HIDDENOPER,  'H' },
588   { FLAG_OVERRIDECC,  'c' },
589   { FLAG_WEBIRC,      'W' },
590   { FLAG_SEE_IDLETIME,'t' },
591   { FLAG_SECURITY_SERV,'D' },
592   { FLAG_HIDDENHOST,  'x' }
593 };
594
595 /** Length of #userModeList. */
596 #define USERMODELIST_SIZE sizeof(userModeList) / sizeof(struct UserMode)
597
598 /*
599  * XXX - find a way to get rid of this
600  */
601 /** Nasty global buffer used for communications with umode_str() and others. */
602 static char umodeBuf[BUFSIZE];
603
604 /** Try to set a user's nickname.
605  * If \a sptr is a server, the client is being introduced for the first time.
606  * @param[in] cptr Client to set nickname.
607  * @param[in] sptr Client sending the NICK.
608  * @param[in] nick New nickname.
609  * @param[in] parc Number of arguments to NICK.
610  * @param[in] parv Argument list to NICK.
611  * @param[in] force Boolean; forced nickchange
612  * @return CPTR_KILLED if \a cptr was killed, else 0.
613  */
614 int set_nick_name(struct Client* cptr, struct Client* sptr,
615                   const char* nick, int parc, char* parv[], unsigned int force)
616 {
617   if (IsServer(sptr)) {
618
619     /*
620      * A server introducing a new client, change source
621      */
622     struct Client* new_client = make_client(cptr, STAT_UNKNOWN);
623     assert(0 != new_client);
624
625     cli_hopcount(new_client) = atoi(parv[2]);
626     cli_lastnick(new_client) = atoi(parv[3]);
627
628     /*
629      * Set new nick name.
630      */
631     strcpy(cli_name(new_client), nick);
632     cli_user(new_client) = make_user(new_client);
633     cli_user(new_client)->server = sptr;
634     SetRemoteNumNick(new_client, parv[parc - 2]);
635     /*
636      * IP# of remote client
637      */
638     base64toip(parv[parc - 3], &cli_ip(new_client));
639
640     add_client_to_list(new_client);
641     hAddClient(new_client);
642
643     cli_serv(sptr)->ghost = 0;        /* :server NICK means end of net.burst */
644     ircd_strncpy(cli_username(new_client), parv[4], USERLEN);
645     ircd_strncpy(cli_user(new_client)->username, parv[4], USERLEN);
646     ircd_strncpy(cli_user(new_client)->host, parv[5], HOSTLEN);
647     ircd_strncpy(cli_user(new_client)->realhost, parv[5], HOSTLEN);
648     ircd_strncpy(cli_info(new_client), parv[parc - 1], REALLEN);
649
650     Count_newremoteclient(UserStats, sptr);
651
652     if (parc > 7 && *parv[6] == '+') {
653       /* (parc-4) -3 for the ip, numeric nick, realname */
654       set_user_mode(cptr, new_client, parc-7, parv+4, ALLOWMODES_WITHSECSERV);
655     }
656
657     return register_user(cptr, new_client);
658   }
659   else if ((cli_name(sptr))[0]) {
660     /*
661      * Client changing its nick
662      *
663      * If the client belongs to me, then check to see
664      * if client is on any channels where it is currently
665      * banned.  If so, do not allow the nick change to occur.
666      */
667     if (MyUser(sptr)) {
668       const char* channel_name;
669       struct Membership *member;
670       if (!force && !IsXtraOp(sptr) && (channel_name = find_no_nickchange_channel(sptr))) {
671         return send_reply(cptr, ERR_BANNICKCHANGE, channel_name);
672       }
673       /*
674        * Refuse nick change if the last nick change was less
675        * then 30 seconds ago. This is intended to get rid of
676        * clone bots doing NICK FLOOD. -SeKs
677        * If someone didn't change their nick for more then 60 seconds
678        * however, allow to do two nick changes immediately after another
679        * before limiting the nick flood. -Run
680        */
681       if (!force && (CurrentTime < cli_nextnick(cptr)))
682       {
683         cli_nextnick(cptr) += 2;
684         send_reply(cptr, ERR_NICKTOOFAST, parv[1],
685                    cli_nextnick(cptr) - CurrentTime);
686         /* Send error message */
687         sendcmdto_one(cptr, CMD_NICK, cptr, "%s", cli_name(cptr));
688         /* bounce NICK to user */
689         return 0;                /* ignore nick change! */
690       }
691       else if(!force) {
692         /* Limit total to 1 change per NICK_DELAY seconds: */
693         cli_nextnick(cptr) += NICK_DELAY;
694         /* However allow _maximal_ 1 extra consecutive nick change: */
695         if (cli_nextnick(cptr) < CurrentTime)
696           cli_nextnick(cptr) = CurrentTime;
697       }
698       /* Invalidate all bans against the user so we check them again */
699       for (member = (cli_user(cptr))->channel; member;
700            member = member->next_channel)
701         ClearBanValid(member);
702     }
703     /*
704      * Also set 'lastnick' to current time, if changed.
705      */
706     if (0 != ircd_strcmp(parv[0], nick))
707       cli_lastnick(sptr) = (sptr == cptr) ? TStime() : atoi(parv[2]);
708
709     /*
710      * Client just changing his/her nick. If he/she is
711      * on a channel, send note of change to all clients
712      * on that channel. Propagate notice to other servers.
713      */
714     if (IsUser(sptr)) {
715       sendcmdto_common_channels_butone(sptr, CMD_NICK, NULL, ":%s", nick);
716       add_history(sptr, 1);
717       sendcmdto_serv_butone(sptr, CMD_NICK, cptr, "%s %Tu", nick,
718                             cli_lastnick(sptr));
719     }
720     else
721       sendcmdto_one(sptr, CMD_NICK, sptr, ":%s", nick);
722
723     if ((cli_name(sptr))[0])
724       hRemClient(sptr);
725     strcpy(cli_name(sptr), nick);
726     hAddClient(sptr);
727   }
728   else {
729     /* Local client setting NICK the first time */
730     strcpy(cli_name(sptr), nick);
731     hAddClient(sptr);
732     return auth_set_nick(cli_auth(sptr), nick);
733   }
734   return 0;
735 }
736
737 /** Calculate the hash value for a target.
738  * @param[in] target Pointer to target, cast to unsigned int.
739  * @return Hash value constructed from the pointer.
740  */
741 static unsigned char hash_target(unsigned int target)
742 {
743   return (unsigned char) (target >> 16) ^ (target >> 8);
744 }
745
746 /** Records \a target as a recent target for \a sptr.
747  * @param[in] sptr User who has sent to a new target.
748  * @param[in] target Target to add.
749  */
750 void
751 add_target(struct Client *sptr, void *target)
752 {
753   /* Ok, this shouldn't work esp on alpha
754   */
755   unsigned char  hash = hash_target((unsigned long) target);
756   unsigned char* targets;
757   int            i;
758   assert(0 != sptr);
759   assert(cli_local(sptr));
760
761   targets = cli_targets(sptr);
762
763   /* 
764    * Already in table?
765    */
766   for (i = 0; i < MAXTARGETS; ++i) {
767     if (targets[i] == hash)
768       return;
769   }
770   /*
771    * New target
772    */
773   memmove(&targets[RESERVEDTARGETS + 1],
774           &targets[RESERVEDTARGETS], MAXTARGETS - RESERVEDTARGETS - 1);
775   targets[RESERVEDTARGETS] = hash;
776 }
777
778 /** Check whether \a sptr can send to or join \a target yet.
779  * @param[in] sptr User trying to join a channel or send a message.
780  * @param[in] target Target of the join or message.
781  * @param[in] name Name of the target.
782  * @param[in] created If non-zero, trying to join a new channel.
783  * @return Non-zero if too many target changes; zero if okay to send.
784  */
785 int check_target_limit(struct Client *sptr, void *target, const char *name,
786     int created)
787 {
788   unsigned char hash = hash_target((unsigned long) target);
789   int            i;
790   unsigned char* targets;
791
792   assert(0 != sptr);
793   assert(cli_local(sptr));
794   targets = cli_targets(sptr);
795
796   if(HasPriv(sptr, PRIV_UNLIMITED_TARGET))
797     return 0;
798
799   /*
800    * Same target as last time?
801    */
802   if (targets[0] == hash)
803     return 0;
804   for (i = 1; i < MAXTARGETS; ++i) {
805     if (targets[i] == hash) {
806       memmove(&targets[1], &targets[0], i);
807       targets[0] = hash;
808       return 0;
809     }
810   }
811   /*
812    * New target
813    */
814   if (!created) {
815     if (CurrentTime < cli_nexttarget(sptr)) {
816       /* If user is invited to channel, give him/her a free target */
817       if (IsChannelName(name) && IsInvited(sptr, target))
818         return 0;
819
820       if (cli_nexttarget(sptr) - CurrentTime < TARGET_DELAY + 8) {
821         /*
822          * No server flooding
823          */
824         cli_nexttarget(sptr) += 2;
825         send_reply(sptr, ERR_TARGETTOOFAST, name,
826                    cli_nexttarget(sptr) - CurrentTime);
827       }
828       return 1;
829     }
830     else {
831       cli_nexttarget(sptr) += TARGET_DELAY;
832       if (cli_nexttarget(sptr) < CurrentTime - (TARGET_DELAY * (MAXTARGETS - 1)))
833         cli_nexttarget(sptr) = CurrentTime - (TARGET_DELAY * (MAXTARGETS - 1));
834     }
835   }
836   memmove(&targets[1], &targets[0], MAXTARGETS - 1);
837   targets[0] = hash;
838   return 0;
839 }
840
841 /** Allows a channel operator to avoid target change checks when
842  * sending messages to users on their channel.
843  * @param[in] source User sending the message.
844  * @param[in] nick Destination of the message.
845  * @param[in] channel Name of channel being sent to.
846  * @param[in] text Message to send.
847  * @param[in] is_notice If non-zero, use CNOTICE instead of CPRIVMSG.
848  */
849 /* Added 971023 by Run. */
850 int whisper(struct Client* source, const char* nick, const char* channel,
851             const char* text, int is_notice)
852 {
853   struct Client*     dest;
854   struct Channel*    chptr;
855   struct Membership* membership;
856
857   assert(0 != source);
858   assert(0 != nick);
859   assert(0 != channel);
860   assert(MyUser(source));
861
862   if (!(dest = FindUser(nick))) {
863     return send_reply(source, ERR_NOSUCHNICK, nick);
864   }
865   if (!(chptr = FindChannel(channel))) {
866     return send_reply(source, ERR_NOSUCHCHANNEL, channel);
867   }
868   /*
869    * compare both users channel lists, instead of the channels user list
870    * since the link is the same, this should be a little faster for channels
871    * with a lot of users
872    */
873   for (membership = cli_user(source)->channel; membership; membership = membership->next_channel) {
874     if (chptr == membership->channel)
875       break;
876   }
877   if (0 == membership) {
878     return send_reply(source, ERR_NOTONCHANNEL, chptr->chname);
879   }
880   if (!IsVoicedOrOpped(membership)) {
881     return send_reply(source, ERR_VOICENEEDED, chptr->chname);
882   }
883   /*
884    * lookup channel in destination
885    */
886   assert(0 != cli_user(dest));
887   for (membership = cli_user(dest)->channel; membership; membership = membership->next_channel) {
888     if (chptr == membership->channel)
889       break;
890   }
891   if (0 == membership || IsZombie(membership)) {
892     return send_reply(source, ERR_USERNOTINCHANNEL, cli_name(dest), chptr->chname);
893   }
894   if (is_silenced(source, dest))
895     return 0;
896           
897   if (is_notice)
898     sendcmdto_one(source, CMD_NOTICE, dest, "%C :%s", dest, text);
899   else
900   {
901     if (cli_user(dest)->away)
902       send_reply(source, RPL_AWAY, cli_name(dest), cli_user(dest)->away);
903     sendcmdto_one(source, CMD_PRIVATE, dest, "%C :%s", dest, text);
904   }
905   return 0;
906 }
907
908
909 /** Send a user mode change for \a cptr to neighboring servers.
910  * @param[in] cptr User whose mode is changing.
911  * @param[in] sptr Client who sent us the mode change message.
912  * @param[in] old Prior set of user flags.
913  * @param[in] prop If non-zero, also include FLAG_OPER.
914  */
915 void send_umode_out(struct Client *cptr, struct Client *sptr,
916                     struct Flags *old, int prop)
917 {
918   int i, server = 0, ret;
919   struct Client *acptr;
920
921   if(cptr && (IsServer(cptr) || IsMe(cptr))) server = 1;
922
923   ret = send_umode(NULL, sptr, old, prop ? SEND_UMODES : SEND_UMODES_BUT_OPER, server);
924
925   for (i = HighestFd; i >= 0; i--)
926   {
927     if ((acptr = LocalClientArray[i]) && IsServer(acptr) &&
928         (acptr != cptr) && (acptr != sptr) && *umodeBuf)
929       sendcmdto_one(sptr, CMD_MODE, acptr, ret?"%s %s":"%s :%s", cli_name(sptr), umodeBuf);
930   }
931   if (cptr && MyUser(cptr))
932     send_umode(cptr, sptr, old, ALL_UMODES, 0);
933 }
934
935
936 /** Call \a fmt for each Client named in \a names.
937  * @param[in] sptr Client requesting information.
938  * @param[in] names Space-delimited list of nicknames.
939  * @param[in] rpl Base reply string for messages.
940  * @param[in] fmt Formatting callback function.
941  */
942 void send_user_info(struct Client* sptr, char* names, int rpl, InfoFormatter fmt)
943 {
944   char*          name;
945   char*          p = 0;
946   int            arg_count = 0;
947   int            users_found = 0;
948   struct Client* acptr;
949   struct MsgBuf* mb;
950
951   assert(0 != sptr);
952   assert(0 != names);
953   assert(0 != fmt);
954
955   mb = msgq_make(sptr, rpl_str(rpl), cli_name(&me), cli_name(sptr));
956
957   for (name = ircd_strtok(&p, names, " "); name; name = ircd_strtok(&p, 0, " ")) {
958     if ((acptr = FindUser(name))) {
959       if (users_found++)
960         msgq_append(0, mb, " ");
961       (*fmt)(acptr, sptr, mb);
962     }
963     if (5 == ++arg_count)
964       break;
965   }
966   send_buffer(sptr, mb, 0);
967   msgq_clean(mb);
968 }
969
970 /** Set \a flag on \a cptr and possibly hide the client's hostmask.
971  * @param[in,out] cptr User who is getting a new flag.
972  * @param[in] flag Some flag that affects host-hiding (FLAG_HIDDENHOST, FLAG_ACCOUNT, FLAG_FAKEHOST).
973  * @return Zero.
974  */
975  
976 int
977 hide_hostmask(struct Client *cptr, unsigned int flag) {
978   return hide_ident_hostmask(cptr, flag, NULL);
979 }
980
981 int
982 hide_ident_hostmask(struct Client *cptr, unsigned int flag, char *username)
983 {
984   struct Membership *chan;
985   char buf[HOSTLEN];
986
987   switch (flag) {
988   case FLAG_HIDDENHOST:
989     /* Local users cannot set +x unless FEAT_HOST_HIDING is true. */
990     if (MyConnect(cptr) && !feature_bool(FEAT_HOST_HIDING))
991       return 0;
992     break;
993   case FLAG_ACCOUNT:
994   case FLAG_FAKEHOST:
995     /* Invalidate all bans against the user so we check them again */
996     for (chan = (cli_user(cptr))->channel; chan;
997          chan = chan->next_channel)
998       ClearBanValid(chan);
999     break;
1000   default:
1001     /* default: no special handling */
1002     break;
1003   }
1004
1005   /* Set flags and stop if no fakehost has to be applied. */
1006   SetFlag(cptr, flag);
1007   if(!HasHiddenHost(cptr))
1008     return 0;
1009
1010   /* Generate new fakehost. */
1011   if(IsFakeHost(cptr)) ircd_strncpy(buf, cli_user(cptr)->fakehost, HOSTLEN);
1012   else if (IsAccount(cptr)) ircd_snprintf(0, buf, HOSTLEN, "%s.%s", cli_user(cptr)->account, feature_str(FEAT_HIDDEN_HOST));
1013   else return 0;
1014   if(strncmp(buf, cli_user(cptr)->host, HOSTLEN) == 0) return 0;
1015
1016   /* Remove all "valid" marks on the bans. This forces them to be
1017    * rechecked if the ban is accessed again.
1018    */
1019   for(chan = (cli_user(cptr))->channel; chan; chan = chan->next_channel) {
1020     ClearBanValid(chan);
1021   }
1022
1023   /* Quit user and set the previously generated fakehost. */
1024   sendcmdto_common_channels_butone(cptr, CMD_QUIT, cptr, ":Registered");
1025   ircd_strncpy(cli_user(cptr)->host, buf, HOSTLEN);
1026
1027   /* spoof also the username if username is passed */
1028   if(username) {
1029     ircd_strncpy(cli_user(cptr)->username, username, USERLEN);
1030      /* ok, the client is now fully hidden, so let them know -- hikari */
1031     if (MyConnect(cptr))
1032       send_reply(cptr, RPL_HOSTUSERHIDDEN, cli_user(cptr)->username, cli_user(cptr)->host);
1033   } else {
1034     /* ok, the client is now fully hidden, so let them know -- hikari */
1035     if (MyConnect(cptr))
1036       send_reply(cptr, RPL_HOSTHIDDEN, cli_user(cptr)->host);
1037   }
1038
1039   /*
1040    * Go through all channels the client was on, rejoin him
1041    * and set the modes, if any
1042    */
1043   for (chan = cli_user(cptr)->channel; chan; chan = chan->next_channel)
1044   {
1045     if (IsZombie(chan))
1046       continue;
1047     /* If the channel has delayed joins, we have to handle the join especially. */
1048     if((!(chan->channel->mode.mode & MODE_DELJOINS) && !IsInvisibleJoin(chan)) || IsChanOp(chan) || HasVoice(chan)) {
1049         sendcmdto_channel_butserv_butone(cptr, CMD_JOIN, chan->channel, cptr, 0,
1050                                          "%H", chan->channel);
1051         if(IsChanOp(chan) && HasVoice(chan)) {
1052             sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan->channel, cptr, 0,
1053                                              "%H +ov %C %C", chan->channel, cptr,
1054                                              cptr);
1055         }
1056         else if(IsChanOp(chan) || HasVoice(chan)) {
1057             sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan->channel, cptr, 0,
1058                                              "%H +%c %C", chan->channel, IsChanOp(chan) ? 'o' : 'v', cptr);
1059         }
1060     }
1061     else {
1062         SetDelayedJoin(chan);
1063     }
1064   }
1065   return 0;
1066 }
1067
1068 /** Set a user's mode.  This function checks that \a cptr is trying to
1069  * set his own mode, prevents local users from setting inappropriate
1070  * modes through this function, and applies any other side effects of
1071  * a successful mode change.
1072  *
1073  * @param[in,out] cptr User setting someone's mode.
1074  * @param[in] sptr Client who sent the mode change message.
1075  * @param[in] parc Number of parameters in \a parv.
1076  * @param[in] parv Parameters to MODE.
1077  * @param[in] allow_modes ALLOWMODES_ANY for any mode, ALLOWMODES_DEFAULT for 
1078  *                        only permitting legitimate default user modes.
1079  * @return Zero.
1080  */
1081 int set_user_mode(struct Client *cptr, struct Client *sptr, int parc, 
1082                 char *parv[], int allow_modes)
1083 {
1084   char** p;
1085   char*  m;
1086   int what;
1087   int i;
1088   struct Flags setflags;
1089   unsigned int tmpmask = 0;
1090   int snomask_given = 0;
1091   char buf[BUFSIZE];
1092   int prop = 0;
1093   int do_host_hiding = 0;
1094   char* account = NULL, *fakehost = NULL;
1095   struct Membership *chan;
1096
1097   what = MODE_ADD;
1098
1099   if (parc < 3)
1100   {
1101     m = buf;
1102     *m++ = '+';
1103     for (i = 0; i < USERMODELIST_SIZE; i++)
1104     {
1105       if (HasFlag(sptr, userModeList[i].flag) &&
1106           (userModeList[i].flag != FLAG_ACCOUNT) &&
1107           (userModeList[i].flag != FLAG_FAKEHOST))
1108         *m++ = userModeList[i].c;
1109     }
1110     *m = '\0';
1111     send_reply(sptr, RPL_UMODEIS, buf);
1112     if (HasFlag(sptr, FLAG_SERVNOTICE) && MyConnect(sptr)
1113         && cli_snomask(sptr) !=
1114         (unsigned int)(IsOper(sptr) ? SNO_OPERDEFAULT : SNO_DEFAULT))
1115       send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr));
1116     return 0;
1117   }
1118
1119   /*
1120    * find flags already set for user
1121    * why not just copy them?
1122    */
1123   setflags = cli_flags(sptr);
1124
1125   if (MyConnect(sptr))
1126     tmpmask = cli_snomask(sptr);
1127
1128   /*
1129    * parse mode change string(s)
1130    */
1131   for (p = &parv[2]; *p && p<&parv[parc]; p++) {       /* p is changed in loop too */
1132     for (m = *p; *m; m++) {
1133       switch (*m) {
1134       case '+':
1135         what = MODE_ADD;
1136         break;
1137       case '-':
1138         what = MODE_DEL;
1139         break;
1140       case 's':
1141         if (*(p + 1) && is_snomask(*(p + 1))) {
1142           snomask_given = 1;
1143           tmpmask = umode_make_snomask(tmpmask, *++p, what);
1144           tmpmask &= (IsAnOper(sptr) ? SNO_ALL : SNO_USER);
1145         }
1146         else
1147           tmpmask = (what == MODE_ADD) ?
1148               (IsAnOper(sptr) ? SNO_OPERDEFAULT : SNO_DEFAULT) : 0;
1149         if (tmpmask)
1150           SetServNotice(sptr);
1151         else
1152           ClearServNotice(sptr);
1153         break;
1154       case 'w':
1155         if (what == MODE_ADD)
1156           SetWallops(sptr);
1157         else
1158           ClearWallops(sptr);
1159         break;
1160       case 'o':
1161         if (what == MODE_ADD)
1162           SetOper(sptr);
1163         else {
1164           ClrFlag(sptr, FLAG_OPER);
1165           ClrFlag(sptr, FLAG_LOCOP);
1166           if (MyConnect(sptr))
1167           {
1168             tmpmask = cli_snomask(sptr) & ~SNO_OPER;
1169             cli_handler(sptr) = CLIENT_HANDLER;
1170           }
1171         }
1172         break;
1173       case 'O':
1174         if (what == MODE_ADD)
1175           SetLocOp(sptr);
1176         else
1177         { 
1178           ClrFlag(sptr, FLAG_OPER);
1179           ClrFlag(sptr, FLAG_LOCOP);
1180           if (MyConnect(sptr))
1181           {
1182             tmpmask = cli_snomask(sptr) & ~SNO_OPER;
1183             cli_handler(sptr) = CLIENT_HANDLER;
1184           }
1185         }
1186         break;
1187       case 'i':
1188         if (what == MODE_ADD)
1189           SetInvisible(sptr);
1190         else
1191           ClearInvisible(sptr);
1192         break;
1193       case 'd':
1194         if (what == MODE_ADD)
1195           SetDeaf(sptr);
1196         else
1197           ClearDeaf(sptr);
1198         break;
1199       case 'c':
1200         if (what == MODE_ADD)
1201             SetOverrideCC(sptr);
1202         else
1203             ClearOverrideCC(sptr);
1204         break;
1205       case 'k':
1206         if (what == MODE_ADD)
1207           SetChannelService(sptr);
1208         else
1209           ClearChannelService(sptr);
1210         break;
1211       case 'g':
1212         if (what == MODE_ADD)
1213           SetDebug(sptr);
1214         else
1215           ClearDebug(sptr);
1216         break;
1217       case 'x':
1218         if(what == MODE_ADD && !FlagHas(&setflags, FLAG_HIDDENHOST) &&
1219            (!MyConnect(sptr) || feature_bool(FEAT_HOST_HIDING))) {
1220             do_host_hiding = 1;
1221             SetHiddenHost(sptr);
1222         }
1223         break;
1224       case 'n':
1225         if (what == MODE_ADD)
1226           SetNoChan(sptr);
1227         else
1228           ClearNoChan(sptr);
1229         break;
1230       case 'I':
1231         if (what == MODE_ADD)
1232           SetNoIdle(sptr);
1233         else
1234           ClearNoIdle(sptr);
1235         break;
1236       case 'X':
1237         if (what == MODE_ADD)
1238            SetXtraOp(sptr);
1239         else
1240            ClearXtraOp(sptr);
1241         break;
1242       case 'S':
1243         if (what == MODE_ADD)
1244            SetNetServ(sptr);
1245         else
1246            ClearNetServ(sptr);
1247         break;
1248       case 'H':
1249         if (what == MODE_ADD)
1250            SetHiddenOper(sptr);
1251         else
1252            ClearHiddenOper(sptr);
1253         break;
1254           case 'D':
1255         if (what == MODE_ADD)
1256            SetSecurityServ(sptr);
1257         else
1258            ClearSecurityServ(sptr);
1259         break;
1260       case 'W':
1261         if (what == MODE_ADD)
1262           SetWebIRC(sptr);
1263         else
1264           ClearWebIRC(sptr);
1265         break;
1266       case 'r':
1267         if (*(p + 1) && (what == MODE_ADD)) {
1268           account = *(++p);
1269           SetAccount(sptr);
1270           for(chan = (cli_user(sptr))->channel; chan; chan = chan->next_channel) ClearBanValid(chan);
1271           if(HasFlag(sptr, FLAG_HIDDENHOST))
1272             do_host_hiding = 1;
1273         }
1274         /* There is no -r */
1275         break;
1276       case 'f':
1277         if (*(p + 1) && (what == MODE_ADD)) {
1278           fakehost = *(++p);
1279           SetFakeHost(sptr);
1280           for(chan = (cli_user(sptr))->channel; chan; chan = chan->next_channel) ClearBanValid(chan);
1281           if(HasFlag(sptr, FLAG_HIDDENHOST))
1282             do_host_hiding = 1;
1283         }
1284         /* There is no -f */
1285         break;
1286       case 't': /* This can only be set by servers and cannot be removed. */
1287         if (what == MODE_ADD)
1288           SetSeeIdletime(sptr);
1289         break;
1290 #ifdef OLD_OGN_IRCU_COMPAT
1291       case 'z': /* Formerly SSL mode; we ignore it. */
1292         break;
1293 #endif
1294       default:
1295         send_reply(sptr, ERR_UMODEUNKNOWNFLAG, *m);
1296         break;
1297       }
1298     }
1299   }
1300   /*
1301    * Evaluate rules for new user mode
1302    * Stop users making themselves operators too easily:
1303    */
1304   if (!IsServer(cptr) && !IsMe(cptr))
1305   {
1306     if (!FlagHas(&setflags, FLAG_OPER) && IsOper(sptr))
1307       ClearOper(sptr);
1308     if (!FlagHas(&setflags, FLAG_LOCOP) && IsLocOp(sptr))
1309       ClearLocOp(sptr);
1310     if (!FlagHas(&setflags, FLAG_ACCOUNT) && IsAccount(sptr))
1311       ClrFlag(sptr, FLAG_ACCOUNT);
1312     if (!FlagHas(&setflags, FLAG_FAKEHOST) && IsFakeHost(sptr))
1313       ClrFlag(sptr, FLAG_FAKEHOST);
1314     if (!FlagHas(&setflags, FLAG_SEE_IDLETIME) && IsSeeIdletime(sptr))
1315       ClrFlag(sptr, FLAG_SEE_IDLETIME);
1316     /*
1317      * new umode; servers and privileged opers can set it, local users cannot;
1318      * prevents users from /kick'ing or /mode -o'ing
1319      */
1320     if (!FlagHas(&setflags, FLAG_CHSERV) && IsChannelService(sptr) && !HasPriv(sptr, PRIV_UMODE_CHSERV))
1321       ClearChannelService(sptr);
1322     if (!FlagHas(&setflags, FLAG_NOCHAN) && IsNoChan(sptr) && !HasPriv(sptr, PRIV_UMODE_NOCHAN))
1323       ClearNoChan(sptr);
1324     if (!FlagHas(&setflags, FLAG_NOIDLE) && IsNoIdle(sptr) && !HasPriv(sptr, PRIV_UMODE_NOIDLE))
1325       ClearNoIdle(sptr);
1326     if (!FlagHas(&setflags, FLAG_XTRAOP) && IsXtraOp(sptr) && (!IsOper(sptr) || !HasPriv(sptr, PRIV_UMODE_XTRAOP)))
1327       ClearXtraOp(sptr);
1328     if (!FlagHas(&setflags, FLAG_NETSERV) && IsNetServ(sptr) && (!HasPriv(sptr, PRIV_UMODE_NETSERV) || !HasFlag(sptr, FLAG_SECURITY_SERV)))
1329       ClearNetServ(sptr);
1330     if (!FlagHas(&setflags, FLAG_HIDDENOPER) && IsHiddenOper(sptr) && !IsOper(sptr))
1331       ClearHiddenOper(sptr);
1332     if (!FlagHas(&setflags, FLAG_OVERRIDECC) && IsOverrideCC(sptr) && !HasPriv(sptr, PRIV_UMODE_OVERRIDECC))
1333       ClearOverrideCC(sptr);
1334     /* Opers are able to fake the webirc usermode only if FEAT_FAKE_WEBIRC is true. */
1335     if (!FlagHas(&setflags, FLAG_WEBIRC) && IsWebIRC(sptr) && !(feature_bool(FEAT_FAKE_WEBIRC) && IsOper(sptr)))
1336       ClearWebIRC(sptr);
1337     /*
1338      * only send wallops to opers
1339      */
1340     if (feature_bool(FEAT_WALLOPS_OPER_ONLY) && !IsAnOper(sptr) &&
1341         !FlagHas(&setflags, FLAG_WALLOP))
1342       ClearWallops(sptr);
1343     if (feature_bool(FEAT_HIS_SNOTICES_OPER_ONLY) && MyConnect(sptr) &&
1344         !IsAnOper(sptr) && !FlagHas(&setflags, FLAG_SERVNOTICE))
1345     {
1346       ClearServNotice(sptr);
1347       set_snomask(sptr, 0, SNO_SET);
1348     }
1349     if (feature_bool(FEAT_HIS_DEBUG_OPER_ONLY) &&
1350         !IsAnOper(sptr) && !FlagHas(&setflags, FLAG_DEBUG))
1351       ClearDebug(sptr);
1352   }
1353   if (allow_modes != ALLOWMODES_WITHSECSERV) {
1354     if (!FlagHas(&setflags, FLAG_SECURITY_SERV) && IsSecurityServ(sptr)) {
1355       ClearSecurityServ(sptr);
1356           sendto_opmask_butone(0, SNO_OLDSNO, "Someone tried to set mode +D to %s - Access denied",cli_name(sptr));
1357           }
1358   }
1359   if (MyConnect(sptr))
1360   {
1361     if ((FlagHas(&setflags, FLAG_OPER) || FlagHas(&setflags, FLAG_LOCOP)) &&
1362         !IsAnOper(sptr))
1363       det_confs_butmask(sptr, CONF_CLIENT & ~CONF_OPERATOR);
1364
1365     if (SendServNotice(sptr))
1366     {
1367       if (tmpmask != cli_snomask(sptr))
1368         set_snomask(sptr, tmpmask, SNO_SET);
1369       if (cli_snomask(sptr) && snomask_given)
1370         send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr));
1371     }
1372     else
1373       set_snomask(sptr, 0, SNO_SET);
1374   }
1375   /*
1376    * Compare new flags with old flags and send string which
1377    * will cause servers to update correctly.
1378    */
1379   if (!FlagHas(&setflags, FLAG_ACCOUNT) && IsAccount(sptr)) {
1380       int len = ACCOUNTLEN;
1381       char *ts;
1382       if ((ts = strchr(account, ':'))) {
1383         len = (ts++) - account;
1384         cli_user(sptr)->acc_create = atoi(ts);
1385         Debug((DEBUG_DEBUG, "Received timestamped account in user mode; "
1386               "account \"%s\", timestamp %Tu", account,
1387               cli_user(sptr)->acc_create));
1388       }
1389       ircd_strncpy(cli_user(sptr)->account, account, len);
1390   }
1391   if (!FlagHas(&setflags, FLAG_FAKEHOST) && IsFakeHost(sptr)) {
1392     ircd_strncpy(cli_user(sptr)->fakehost, fakehost, HOSTLEN);
1393   }
1394
1395   if (IsRegistered(sptr)) {
1396     if(do_host_hiding)
1397       hide_hostmask(sptr, 0);
1398
1399     if (!FlagHas(&setflags, FLAG_OPER) && IsOper(sptr)) {
1400       /* user now oper */
1401       ++UserStats.opers;
1402       client_set_privs(sptr, NULL); /* may set propagate privilege */
1403       prop = 1;
1404       if(MyConnect(sptr)) {
1405         sendto_opmask_butone(0, SNO_OLDSNO, "%s (%s@%s) is now operator (%c)",
1406                              cli_name(sptr), cli_user(sptr)->username,
1407                              cli_sockhost(sptr), IsOper(sptr) ? 'O' : 'o');
1408         log_write(LS_OPER, L_INFO, 0, "OPER (<OOM>) by (%#C)", sptr);
1409         cli_handler(sptr) = OPER_HANDLER;
1410         send_reply(sptr, RPL_YOUREOPER);
1411       }
1412     }
1413     if (FlagHas(&setflags, FLAG_OPER) && !IsOper(sptr)) {
1414       prop = 1;
1415     }
1416     /* remember propagate privilege setting */
1417     if (HasPriv(sptr, PRIV_PROPAGATE)) {
1418       prop = 1;
1419     }
1420     if (FlagHas(&setflags, FLAG_OPER) && !IsOper(sptr)) {
1421       /* user no longer oper */
1422       assert(UserStats.opers > 0);
1423       --UserStats.opers;
1424       client_set_privs(sptr, NULL); /* will clear propagate privilege */
1425       client_set_uprivs(sptr, cli_confs(sptr)->value.aconf);
1426     }
1427     if (FlagHas(&setflags, FLAG_INVISIBLE) && !IsInvisible(sptr)) {
1428       assert(UserStats.inv_clients > 0);
1429       --UserStats.inv_clients;
1430     }
1431     if (!FlagHas(&setflags, FLAG_INVISIBLE) && IsInvisible(sptr)) {
1432       ++UserStats.inv_clients;
1433     }
1434     assert(UserStats.opers <= UserStats.clients + UserStats.unknowns);
1435     assert(UserStats.inv_clients <= UserStats.clients + UserStats.unknowns);
1436     send_umode_out(cptr, sptr, &setflags, prop);
1437   }
1438
1439   return 0;
1440 }
1441
1442 /** Build a mode string to describe modes for \a cptr.
1443  * @param[in] cptr Some user.
1444  * @return Pointer to a static buffer.
1445  */
1446 char *umode_str(struct Client *cptr)
1447 {
1448   /* Maximum string size: "owidgrx\0" */
1449   char *m = umodeBuf;
1450   int i;
1451   struct Flags c_flags = cli_flags(cptr);
1452
1453   if (!HasPriv(cptr, PRIV_PROPAGATE))
1454     FlagClr(&c_flags, FLAG_OPER);
1455
1456   for (i = 0; i < USERMODELIST_SIZE; ++i)
1457   {
1458     if (FlagHas(&c_flags, userModeList[i].flag) &&
1459         userModeList[i].flag >= FLAG_GLOBAL_UMODES)
1460       *m++ = userModeList[i].c;
1461   }
1462
1463   /* Append the arguments for the flags. They have to be appended
1464    * in the right order. See the order of userModeList[].
1465    */
1466
1467   if (IsAccount(cptr)) {
1468     char* t = cli_user(cptr)->account;
1469
1470     *m++ = ' ';
1471     while ((*m++ = *t++))
1472       ; /* Empty loop */
1473
1474     /* If timestamped, append the timestamp directly to the accountname
1475      * separated with a colon
1476      */
1477     if (cli_user(cptr)->acc_create) {
1478       char nbuf[20];
1479       Debug((DEBUG_DEBUG, "Sending timestamped account in user mode for "
1480             "account \"%s\"; timestamp %Tu", cli_user(cptr)->account,
1481             cli_user(cptr)->acc_create));
1482       ircd_snprintf(0, t = nbuf, sizeof(nbuf), ":%Tu",
1483                     cli_user(cptr)->acc_create);
1484       m--; /* back up over previous nul-termination */
1485       while ((*m++ = *t++))
1486         ; /* Empty loop */
1487     }
1488
1489     --m; /* back up over previous nul-termination */
1490   }
1491
1492   if(IsFakeHost(cptr)) {
1493         char* t = cli_user(cptr)->fakehost;
1494         *m++ = ' ';
1495         while((*m++ = *t++)) ; /* Empty loop */
1496         --m; /* back up over previous nul-termination */
1497   }
1498
1499   *m = '\0';
1500
1501   return umodeBuf;                /* Note: static buffer, gets
1502                                    overwritten by send_umode() */
1503 }
1504
1505 /** Send a mode change string for \a sptr to \a cptr.
1506  * @param[in] cptr Destination of mode change message.
1507  * @param[in] sptr User whose mode has changed.
1508  * @param[in] old Pre-change set of modes for \a sptr.
1509  * @param[in] sendset One of ALL_UMODES, SEND_UMODES_BUT_OPER,
1510  * @param[in] serv_modes Set to 1 if you want to send ACCOUNT and FAKEHOST with this command.
1511  * @return 1 if ":" is already used in the buffer, 0 otherwise. Always 0 if \a serv_modes is 0.
1512  * SEND_UMODES, to select which changed user modes to send.
1513  */
1514 int send_umode(struct Client *cptr, struct Client *sptr, struct Flags *old,
1515                 int sendset, int serv_modes)
1516 {
1517   int i, ret = 0;
1518   int flag;
1519   char *m;
1520   int what = MODE_NULL;
1521   int add_fakehost = 0, add_account = 0;
1522
1523   /*
1524    * Build a string in umodeBuf to represent the change in the user's
1525    * mode between the new (cli_flags(sptr)) and 'old', but skipping
1526    * the modes indicated by sendset.
1527    */
1528   m = umodeBuf;
1529   *m = '\0';
1530   for (i = 0; i < USERMODELIST_SIZE; ++i)
1531   {
1532     flag = userModeList[i].flag;
1533     if (FlagHas(old, flag)
1534         == HasFlag(sptr, flag))
1535       continue;
1536
1537     /* Account is not shown to the user as umode. */
1538     if(flag == FLAG_ACCOUNT) {
1539       if(!serv_modes || FlagHas(old, flag)) continue;
1540       add_account = 1;
1541     }
1542
1543     if(flag == FLAG_FAKEHOST) {
1544       /* Removing a fakehost is not possible. Ignore it. */
1545       if(!serv_modes || FlagHas(old, flag)) continue;
1546       add_fakehost = 1;
1547     }
1548
1549     switch (sendset)
1550     {
1551     case ALL_UMODES:
1552       break;
1553     case SEND_UMODES_BUT_OPER:
1554       if (flag == FLAG_OPER)
1555         continue;
1556       /* and fall through */
1557     case SEND_UMODES:
1558       if (flag < FLAG_GLOBAL_UMODES)
1559         continue;
1560       break;      
1561     }
1562     if (FlagHas(old, flag))
1563     {
1564       if (what == MODE_DEL)
1565         *m++ = userModeList[i].c;
1566       else
1567       {
1568         what = MODE_DEL;
1569         *m++ = '-';
1570         *m++ = userModeList[i].c;
1571       }
1572     }
1573     else /* !FlagHas(old, flag) */
1574     {
1575       if (what == MODE_ADD)
1576         *m++ = userModeList[i].c;
1577       else
1578       {
1579         what = MODE_ADD;
1580         *m++ = '+';
1581         *m++ = userModeList[i].c;
1582       }
1583     }
1584   }
1585
1586   if(add_account) {
1587     char* t = cli_user(sptr)->account;
1588
1589     *m++ = ' ';
1590     if(!add_fakehost) {
1591       *m++ = ':';
1592       ret = 1;
1593     }
1594     while ((*m++ = *t++)) /* Empty loop */ ;
1595     if(cli_user(sptr)->acc_create) {
1596       char nbuf[20];
1597       ircd_snprintf(0, t = nbuf, sizeof(nbuf), ":%Tu", cli_user(sptr)->acc_create);
1598       m--; /* back up over previous nul-termination */
1599       while ((*m++ = *t++)) /* Empty loop */ ;
1600     }
1601     --m; /* back up over previous nul-termination */
1602   }
1603
1604   if(add_fakehost) {
1605     char* t = cli_user(sptr)->fakehost;
1606
1607     *m++ = ' ';
1608     *m++ = ':';
1609     ret = 1;
1610     while((*m++ = *t++)) ; /* Empty loop */
1611     --m; /* back up over previous nul-termination */
1612   }
1613
1614   *m = '\0';
1615   if (*umodeBuf && cptr)
1616     sendcmdto_one(sptr, CMD_MODE, cptr, ret?"%s %s":"%s :%s", cli_name(sptr), umodeBuf);
1617   return ret;
1618 }
1619
1620 /**
1621  * Check to see if this resembles a sno_mask.  It is if 1) there is
1622  * at least one digit and 2) The first digit occurs before the first
1623  * alphabetic character.
1624  * @param[in] word Word to check for sno_mask-ness.
1625  * @return Non-zero if \a word looks like a server notice mask; zero if not.
1626  */
1627 int is_snomask(char *word)
1628 {
1629   if (word)
1630   {
1631     for (; *word; word++)
1632       if (IsDigit(*word))
1633         return 1;
1634       else if (IsAlpha(*word))
1635         return 0;
1636   }
1637   return 0;
1638 }
1639
1640 /** Update snomask \a oldmask according to \a arg and \a what.
1641  * @param[in] oldmask Original user mask.
1642  * @param[in] arg Update string (either a number or '+'/'-' followed by a number).
1643  * @param[in] what MODE_ADD if adding the mask.
1644  * @return New value of service notice mask.
1645  */
1646 unsigned int umode_make_snomask(unsigned int oldmask, char *arg, int what)
1647 {
1648   unsigned int sno_what;
1649   unsigned int newmask;
1650   if (*arg == '+')
1651   {
1652     arg++;
1653     if (what == MODE_ADD)
1654       sno_what = SNO_ADD;
1655     else
1656       sno_what = SNO_DEL;
1657   }
1658   else if (*arg == '-')
1659   {
1660     arg++;
1661     if (what == MODE_ADD)
1662       sno_what = SNO_DEL;
1663     else
1664       sno_what = SNO_ADD;
1665   }
1666   else
1667     sno_what = (what == MODE_ADD) ? SNO_SET : SNO_DEL;
1668   /* pity we don't have strtoul everywhere */
1669   newmask = (unsigned int)atoi(arg);
1670   if (sno_what == SNO_DEL)
1671     newmask = oldmask & ~newmask;
1672   else if (sno_what == SNO_ADD)
1673     newmask |= oldmask;
1674   return newmask;
1675 }
1676
1677 /** Remove \a cptr from the singly linked list \a list.
1678  * @param[in] cptr Client to remove from list.
1679  * @param[in,out] list Pointer to head of list containing \a cptr.
1680  */
1681 static void delfrom_list(struct Client *cptr, struct SLink **list)
1682 {
1683   struct SLink* tmp;
1684   struct SLink* prv = NULL;
1685
1686   for (tmp = *list; tmp; tmp = tmp->next) {
1687     if (tmp->value.cptr == cptr) {
1688       if (prv)
1689         prv->next = tmp->next;
1690       else
1691         *list = tmp->next;
1692       free_link(tmp);
1693       break;
1694     }
1695     prv = tmp;
1696   }
1697 }
1698
1699 /** Set \a cptr's server notice mask, according to \a what.
1700  * @param[in,out] cptr Client whose snomask is updating.
1701  * @param[in] newmask Base value for new snomask.
1702  * @param[in] what One of SNO_ADD, SNO_DEL, SNO_SET, to choose operation.
1703  */
1704 void set_snomask(struct Client *cptr, unsigned int newmask, int what)
1705 {
1706   unsigned int oldmask, diffmask;        /* unsigned please */
1707   int i;
1708   struct SLink *tmp;
1709
1710   oldmask = cli_snomask(cptr);
1711
1712   if (what == SNO_ADD)
1713     newmask |= oldmask;
1714   else if (what == SNO_DEL)
1715     newmask = oldmask & ~newmask;
1716   else if (what != SNO_SET)        /* absolute set, no math needed */
1717     sendto_opmask_butone(0, SNO_OLDSNO, "setsnomask called with %d ?!", what);
1718
1719   newmask &= (IsAnOper(cptr) ? SNO_ALL : SNO_USER);
1720
1721   diffmask = oldmask ^ newmask;
1722
1723   for (i = 0; diffmask >> i; i++) {
1724     if (((diffmask >> i) & 1))
1725     {
1726       if (((newmask >> i) & 1))
1727       {
1728         tmp = make_link();
1729         tmp->next = opsarray[i];
1730         tmp->value.cptr = cptr;
1731         opsarray[i] = tmp;
1732       }
1733       else
1734         /* not real portable :( */
1735         delfrom_list(cptr, &opsarray[i]);
1736     }
1737   }
1738   cli_snomask(cptr) = newmask;
1739 }
1740
1741 /** Check whether \a sptr is allowed to send a message to \a acptr.
1742  * If \a sptr is a remote user, it means some server has an outdated
1743  * SILENCE list for \a acptr, so send the missing SILENCE mask(s) back
1744  * in the direction of \a sptr.  Skip the check if \a sptr is a server.
1745  * @param[in] sptr Client trying to send a message.
1746  * @param[in] acptr Destination of message.
1747  * @return Non-zero if \a sptr is SILENCEd by \a acptr, zero if not.
1748  */
1749 int is_silenced(struct Client *sptr, struct Client *acptr)
1750 {
1751   struct Ban *found;
1752   struct User *user;
1753   size_t buf_used, slen;
1754   char buf[BUFSIZE];
1755
1756   if (IsServer(sptr) || !(user = cli_user(acptr))
1757       || !(found = find_ban(sptr, user->silence)))
1758     return 0;
1759   assert(!(found->flags & BAN_EXCEPTION));
1760   if (!MyConnect(sptr)) {
1761     /* Buffer positive silence to send back. */
1762     buf_used = strlen(found->banstr);
1763     memcpy(buf, found->banstr, buf_used);
1764     /* Add exceptions to buffer. */
1765     for (found = user->silence; found; found = found->next) {
1766       if (!(found->flags & BAN_EXCEPTION))
1767         continue;
1768       slen = strlen(found->banstr);
1769       if (buf_used + slen + 4 > 400) {
1770         buf[buf_used] = '\0';
1771         sendcmdto_one(acptr, CMD_SILENCE, cli_from(sptr), "%C %s", sptr, buf);
1772         buf_used = 0;
1773       }
1774       if (buf_used)
1775         buf[buf_used++] = ',';
1776       buf[buf_used++] = '+';
1777       buf[buf_used++] = '~';
1778       memcpy(buf + buf_used, found->banstr, slen);
1779       buf_used += slen;
1780     }
1781     /* Flush silence buffer. */
1782     if (buf_used) {
1783       buf[buf_used] = '\0';
1784       sendcmdto_one(acptr, CMD_SILENCE, cli_from(sptr), "%C %s", sptr, buf);
1785       buf_used = 0;
1786     }
1787   }
1788   return 1;
1789 }
1790
1791 /** Send RPL_ISUPPORT lines to \a cptr.
1792  * @param[in] cptr Client to send ISUPPORT to.
1793  * @return Zero.
1794  */
1795 int
1796 send_supported(struct Client *cptr)
1797 {
1798   char featurebuf[512];
1799
1800   ircd_snprintf(0, featurebuf, sizeof(featurebuf), FEATURES1, FEATURESVALUES1);
1801   send_reply(cptr, RPL_ISUPPORT, featurebuf);
1802   ircd_snprintf(0, featurebuf, sizeof(featurebuf), FEATURES2, FEATURESVALUES2);
1803   send_reply(cptr, RPL_ISUPPORT, featurebuf);
1804
1805   return 0; /* convenience return, if it's ever needed */
1806 }
1807
1808 /* vim: shiftwidth=2 
1809  */