ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/user.c
Revision: 7925
Committed: Sat Dec 31 13:57:24 2016 UTC (7 years, 2 months ago) by michael
Content type: text/x-csrc
File size: 22394 byte(s)
Log Message:
- Update copyright years

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 1997-2017 ircd-hybrid development team
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 * USA
20 */
21
22 /*! \file user.c
23 * \brief User related functions.
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "list.h"
29 #include "user.h"
30 #include "channel.h"
31 #include "channel_mode.h"
32 #include "client.h"
33 #include "hash.h"
34 #include "id.h"
35 #include "irc_string.h"
36 #include "ircd.h"
37 #include "listener.h"
38 #include "motd.h"
39 #include "numeric.h"
40 #include "conf.h"
41 #include "conf_gecos.h"
42 #include "log.h"
43 #include "server.h"
44 #include "send.h"
45 #include "memory.h"
46 #include "packet.h"
47 #include "rng_mt.h"
48 #include "userhost.h"
49 #include "misc.h"
50 #include "parse.h"
51 #include "watch.h"
52 #include "isupport.h"
53 #include "tls.h"
54
55 static char umode_buffer[IRCD_BUFSIZE];
56
57 const struct user_modes *umode_map[256];
58 const struct user_modes umode_tab[] =
59 {
60 { 'D', UMODE_DEAF },
61 { 'F', UMODE_FARCONNECT },
62 { 'G', UMODE_SOFTCALLERID },
63 { 'H', UMODE_HIDDEN },
64 { 'R', UMODE_REGONLY },
65 { 'S', UMODE_SSL },
66 { 'W', UMODE_WEBIRC },
67 { 'a', UMODE_ADMIN },
68 { 'b', UMODE_BOTS },
69 { 'c', UMODE_CCONN },
70 { 'd', UMODE_DEBUG },
71 { 'e', UMODE_EXTERNAL },
72 { 'f', UMODE_FULL },
73 { 'g', UMODE_CALLERID },
74 { 'i', UMODE_INVISIBLE },
75 { 'j', UMODE_REJ },
76 { 'k', UMODE_SKILL },
77 { 'l', UMODE_LOCOPS },
78 { 'n', UMODE_NCHANGE },
79 { 'o', UMODE_OPER },
80 { 'p', UMODE_HIDECHANS },
81 { 'q', UMODE_HIDEIDLE },
82 { 'r', UMODE_REGISTERED },
83 { 's', UMODE_SERVNOTICE },
84 { 'u', UMODE_UNAUTH },
85 { 'w', UMODE_WALLOP },
86 { 'x', UMODE_HIDDENHOST },
87 { 'y', UMODE_SPY },
88 { '\0', 0 }
89 };
90
91 void
92 user_modes_init(void)
93 {
94 char *umode_buffer_ptr = umode_buffer;
95
96 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
97 {
98 umode_map[tab->c] = tab;
99 *umode_buffer_ptr++ = tab->c;
100 }
101
102 *umode_buffer_ptr = '\0';
103 }
104
105 /* show_lusers()
106 *
107 * inputs - pointer to client
108 * output - NONE
109 * side effects - display to client user counts etc.
110 */
111 void
112 show_lusers(struct Client *client_p)
113 {
114 if (!ConfigServerHide.hide_servers || HasUMode(client_p, UMODE_OPER))
115 sendto_one_numeric(client_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
116 Count.invisi, dlink_list_length(&global_server_list));
117 else
118 sendto_one_numeric(client_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
119 Count.invisi, 1);
120
121 if (Count.oper)
122 sendto_one_numeric(client_p, &me, RPL_LUSEROP, Count.oper);
123
124 if (dlink_list_length(&unknown_list))
125 sendto_one_numeric(client_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
126
127 if (dlink_list_length(&channel_list))
128 sendto_one_numeric(client_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&channel_list));
129
130 if (!ConfigServerHide.hide_servers || HasUMode(client_p, UMODE_OPER))
131 {
132 sendto_one_numeric(client_p, &me, RPL_LUSERME, Count.local, Count.myserver);
133 sendto_one_numeric(client_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
134 }
135 else
136 {
137 sendto_one_numeric(client_p, &me, RPL_LUSERME, Count.total, 0);
138 sendto_one_numeric(client_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
139 }
140
141 sendto_one_numeric(client_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
142
143 if (!ConfigServerHide.hide_servers || HasUMode(client_p, UMODE_OPER))
144 sendto_one_numeric(client_p, &me, RPL_STATSCONN, Count.max_loc_con,
145 Count.max_loc_cli, Count.totalrestartcount);
146
147 if (Count.local > Count.max_loc_cli)
148 Count.max_loc_cli = Count.local;
149
150 if ((Count.local + Count.myserver) > Count.max_loc_con)
151 Count.max_loc_con = Count.local + Count.myserver;
152 }
153
154 /* report_and_set_user_flags()
155 *
156 * inputs - pointer to client_p
157 * - pointer to conf for this user
158 * output - NONE
159 * side effects - Report to user any special flags
160 * they are getting, and set them.
161 */
162 static void
163 report_and_set_user_flags(struct Client *client_p, const struct MaskItem *conf)
164 {
165 /* If this user is being spoofed, tell them so */
166 if (IsConfDoSpoofIp(conf))
167 sendto_one_notice(client_p, &me, ":*** Spoofing your IP");
168
169 /* If this user is in the exception class, set it "E lined" */
170 if (IsConfExemptKline(conf))
171 {
172 AddFlag(client_p, FLAGS_EXEMPTKLINE);
173 sendto_one_notice(client_p, &me, ":*** You are exempt from K/D lines");
174 }
175
176 if (IsConfExemptXline(conf))
177 {
178 AddFlag(client_p, FLAGS_EXEMPTXLINE);
179 sendto_one_notice(client_p, &me, ":*** You are exempt from X lines");
180 }
181
182 if (IsConfExemptResv(conf))
183 {
184 AddFlag(client_p, FLAGS_EXEMPTRESV);
185 sendto_one_notice(client_p, &me, ":*** You are exempt from resvs");
186 }
187
188 /* If this user is exempt from user limits set it "F lined" */
189 if (IsConfExemptLimits(conf))
190 {
191 AddFlag(client_p, FLAGS_NOLIMIT);
192 sendto_one_notice(client_p, &me, ":*** You are exempt from user limits");
193 }
194
195 if (IsConfCanFlood(conf))
196 {
197 AddFlag(client_p, FLAGS_CANFLOOD);
198 sendto_one_notice(client_p, &me, ":*** You are exempt from flood protection");
199 }
200 }
201
202 /* introduce_client()
203 *
204 * inputs - client_p
205 * output - NONE
206 * side effects - This common function introduces a client to the rest
207 * of the net, either from a local client connect or
208 * from a remote connect.
209 */
210 static void
211 introduce_client(struct Client *client_p)
212 {
213 dlink_node *node = NULL;
214 char ubuf[IRCD_BUFSIZE] = "";
215
216 send_umode(client_p, MyConnect(client_p), 0, ubuf);
217 watch_check_hash(client_p, RPL_LOGON);
218
219 if (ubuf[0] == '\0')
220 {
221 ubuf[0] = '+';
222 ubuf[1] = '\0';
223 }
224
225 DLINK_FOREACH(node, local_server_list.head)
226 {
227 struct Client *server_p = node->data;
228
229 if (server_p == client_p->from)
230 continue;
231
232 sendto_one(server_p, ":%s UID %s %u %ju %s %s %s %s %s %s :%s",
233 client_p->servptr->id,
234 client_p->name, client_p->hopcount+1,
235 client_p->tsinfo,
236 ubuf, client_p->username, client_p->host,
237 client_p->sockhost, client_p->id,
238 client_p->account,
239 client_p->info);
240
241 if (!EmptyString(client_p->certfp))
242 sendto_one(server_p, ":%s CERTFP %s", client_p->id, client_p->certfp);
243 }
244 }
245
246 /* user_welcome()
247 *
248 * inputs - client pointer to client to welcome
249 * output - NONE
250 * side effects -
251 */
252 static void
253 user_welcome(struct Client *client_p)
254 {
255 static const char built_date[] = __DATE__ " at " __TIME__;
256
257 if (HasFlag(client_p, FLAGS_SSL))
258 {
259 AddUMode(client_p, UMODE_SSL);
260 sendto_one_notice(client_p, &me, ":*** Connected securely via %s",
261 tls_get_cipher(&client_p->connection->fd.ssl));
262 }
263
264 sendto_one_numeric(client_p, &me, RPL_WELCOME, ConfigServerInfo.network_name,
265 client_p->name);
266 sendto_one_numeric(client_p, &me, RPL_YOURHOST,
267 listener_get_name(client_p->connection->listener), ircd_version);
268 sendto_one_numeric(client_p, &me, RPL_CREATED, built_date);
269 sendto_one_numeric(client_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
270
271 isupport_show(client_p);
272 show_lusers(client_p);
273 motd_signon(client_p);
274 }
275
276 /* check_xline()
277 *
278 * inputs - pointer to client to test
279 * outupt - 1 if exiting 0 if ok
280 * side effects -
281 */
282 static int
283 check_xline(struct Client *client_p)
284 {
285 const struct GecosItem *gecos = NULL;
286
287 if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
288 return 0;
289
290 if ((gecos = gecos_find(client_p->info, match)))
291 {
292 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
293 "X-line Rejecting [%s] [%s], user %s [%s]",
294 client_p->info, gecos->reason,
295 get_client_name(client_p, HIDE_IP),
296 client_p->sockhost);
297
298 ++ServerStats.is_ref;
299 exit_client(client_p, "Bad user info");
300 return 1;
301 }
302
303 return 0;
304 }
305
306 /*! \brief This function is called when both NICK and USER messages
307 * have been accepted for the client, in whatever order. Only
308 * after this, is the UID message propagated.
309 * \param client_p Pointer to given client to introduce
310 */
311 void
312 register_local_user(struct Client *client_p)
313 {
314 const struct MaskItem *conf = NULL;
315
316 assert(client_p == client_p->from);
317 assert(MyConnect(client_p));
318 assert(IsUnknown(client_p));
319 assert(!client_p->connection->registration);
320
321 if (ConfigGeneral.ping_cookie)
322 {
323 if (!HasFlag(client_p, FLAGS_PINGSENT) && !client_p->connection->random_ping)
324 {
325 do
326 client_p->connection->random_ping = genrand_int32();
327 while (!client_p->connection->random_ping);
328
329 sendto_one(client_p, "PING :%u", client_p->connection->random_ping);
330 AddFlag(client_p, FLAGS_PINGSENT);
331 return;
332 }
333
334 if (!HasFlag(client_p, FLAGS_PING_COOKIE))
335 return;
336 }
337
338 client_p->connection->last_privmsg = CurrentTime;
339 /* Straight up the maximum rate of flooding... */
340 client_p->connection->allow_read = MAX_FLOOD_BURST;
341
342 if (!check_client(client_p))
343 return;
344
345 if (!valid_hostname(client_p->host))
346 {
347 sendto_one_notice(client_p, &me, ":*** Notice -- You have an illegal "
348 "character in your hostname");
349 strlcpy(client_p->host, client_p->sockhost, sizeof(client_p->host));
350 }
351
352 conf = client_p->connection->confs.head->data;
353
354 if (!HasFlag(client_p, FLAGS_GOTID))
355 {
356 char username[USERLEN + 1] = "";
357 unsigned int i = 0;
358
359 if (IsNeedIdentd(conf))
360 {
361 ++ServerStats.is_ref;
362 sendto_one_notice(client_p, &me, ":*** Notice -- You need to install "
363 "identd to use this server");
364 exit_client(client_p, "Install identd");
365 return;
366 }
367
368 strlcpy(username, client_p->username, sizeof(username));
369
370 if (!IsNoTilde(conf))
371 client_p->username[i++] = '~';
372
373 for (const char *p = username; *p && i < USERLEN; ++p)
374 client_p->username[i++] = *p;
375
376 client_p->username[i] = '\0';
377 }
378
379 /* Password check */
380 if (!EmptyString(conf->passwd))
381 {
382 if (!match_conf_password(client_p->connection->password, conf))
383 {
384 ++ServerStats.is_ref;
385
386 sendto_one_numeric(client_p, &me, ERR_PASSWDMISMATCH);
387 exit_client(client_p, "Bad Password");
388 return;
389 }
390 }
391
392 /*
393 * Don't free client_p->connection->password here - it can be required
394 * by masked /stats I if there are auth {} blocks with need_password = no;
395 * --adx
396 */
397
398 /*
399 * Report if user has &^>= etc. and set flags as needed in client_p
400 */
401 report_and_set_user_flags(client_p, conf);
402
403 if (IsDead(client_p))
404 return;
405
406 /*
407 * Limit clients -
408 * We want to be able to have servers and F-line clients
409 * connect, so save room for "buffer" connections.
410 * Smaller servers may want to decrease this, and it should
411 * probably be just a percentage of the MAXCLIENTS...
412 * -Taner
413 */
414 if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
415 (Count.local >= GlobalSetOptions.maxclients && !HasFlag(client_p, FLAGS_NOLIMIT)))
416 {
417 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
418 "Too many clients, rejecting %s[%s].",
419 client_p->name, client_p->host);
420 ++ServerStats.is_ref;
421 exit_client(client_p, "Sorry, server is full - try later");
422 return;
423 }
424
425 if (!valid_username(client_p->username, 1))
426 {
427 char buf[IRCD_BUFSIZE] = "";
428
429 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
430 "Invalid username: %s (%s@%s)",
431 client_p->name, client_p->username, client_p->host);
432 ++ServerStats.is_ref;
433 snprintf(buf, sizeof(buf), "Invalid username [%s]", client_p->username);
434 exit_client(client_p, buf);
435 return;
436 }
437
438 if (check_xline(client_p))
439 return;
440
441 const char *id;
442 while (hash_find_id((id = uid_get())))
443 ;
444
445 strlcpy(client_p->id, id, sizeof(client_p->id));
446 hash_add_id(client_p);
447
448 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
449 "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
450 client_p->name, client_p->username, client_p->host,
451 client_p->sockhost,
452 get_client_class(&client_p->connection->confs),
453 client_p->info, client_p->id);
454
455 if (ConfigGeneral.invisible_on_connect)
456 {
457 AddUMode(client_p, UMODE_INVISIBLE);
458 ++Count.invisi;
459 }
460
461 if (++Count.local > Count.max_loc)
462 {
463 Count.max_loc = Count.local;
464
465 if (!(Count.max_loc % 10))
466 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
467 "New maximum local client connections: %u",
468 Count.max_loc);
469 }
470
471 if (++Count.total > Count.max_tot)
472 Count.max_tot = Count.total;
473 ++Count.totalrestartcount;
474
475 assert(client_p->servptr == &me);
476 SetClient(client_p);
477 dlinkAdd(client_p, &client_p->lnode, &client_p->servptr->serv->client_list);
478 dlinkAdd(client_p, &client_p->node, &global_client_list);
479
480 assert(dlinkFind(&unknown_list, client_p));
481
482 dlink_move_node(&client_p->connection->lclient_node,
483 &unknown_list, &local_client_list);
484
485 user_welcome(client_p);
486 userhost_add(client_p->sockhost, 0);
487 AddFlag(client_p, FLAGS_USERHOST);
488
489 introduce_client(client_p);
490 }
491
492 /* register_remote_user()
493 *
494 * inputs - client_p remote or directly connected client
495 * - username to register as
496 * - host name to register as
497 * - server name
498 * output - NONE
499 * side effects - This function is called when a remote client
500 * is introduced by a server.
501 */
502 void
503 register_remote_user(struct Client *client_p)
504 {
505 assert(client_p->servptr->from == client_p->from);
506
507 /*
508 * If the nick has been introduced by a services server,
509 * make it a service as well.
510 */
511 if (HasFlag(client_p->servptr, FLAGS_SERVICE))
512 AddFlag(client_p, FLAGS_SERVICE);
513
514 if (++Count.total > Count.max_tot)
515 Count.max_tot = Count.total;
516
517 SetClient(client_p);
518 dlinkAdd(client_p, &client_p->lnode, &client_p->servptr->serv->client_list);
519 dlinkAdd(client_p, &client_p->node, &global_client_list);
520 userhost_add(client_p->sockhost, 1);
521 AddFlag(client_p, FLAGS_USERHOST);
522
523 if (HasFlag(client_p->servptr, FLAGS_EOB))
524 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
525 "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
526 client_p->servptr->name,
527 client_p->name, client_p->username, client_p->host,
528 client_p->sockhost, client_p->info, client_p->id);
529
530 introduce_client(client_p);
531 }
532
533 /* valid_hostname()
534 *
535 * Inputs - pointer to hostname
536 * Output - 1 if valid, 0 if not
537 * Side effects - check hostname for validity
538 *
539 * NOTE: this doesn't allow a hostname to begin with a dot and
540 * will not allow more dots than chars.
541 */
542 int
543 valid_hostname(const char *hostname)
544 {
545 const char *p = hostname;
546
547 assert(p);
548
549 if (EmptyString(p) || *p == '.' || *p == ':')
550 return 0;
551
552 for (; *p; ++p)
553 if (!IsHostChar(*p))
554 return 0;
555
556 return p - hostname <= HOSTLEN;
557 }
558
559 /* valid_username()
560 *
561 * Inputs - pointer to user
562 * Output - 1 if valid, 0 if not
563 * Side effects - check username for validity
564 *
565 * Absolutely always reject any '*' '!' '?' '@' in an user name
566 * reject any odd control characters names.
567 * Allow '.' in username to allow for "first.last"
568 * style of username
569 */
570 int
571 valid_username(const char *username, const int local)
572 {
573 const char *p = username;
574
575 assert(p);
576
577 if (*p == '~')
578 ++p;
579
580 /*
581 * Reject usernames that don't start with an alphanum
582 * i.e. reject jokers who have '-@somehost' or '.@somehost'
583 * or "-hi-@somehost", "h-----@somehost" would still be accepted.
584 */
585 if (!IsAlNum(*p))
586 return 0;
587
588 if (local)
589 {
590 unsigned int dots = 0;
591
592 while (*++p)
593 {
594 if (*p == '.' && ConfigGeneral.dots_in_ident)
595 {
596 if (++dots > ConfigGeneral.dots_in_ident)
597 return 0;
598 if (!IsUserChar(*(p + 1)))
599 return 0;
600 }
601 else if (!IsUserChar(*p))
602 return 0;
603 }
604 }
605 else
606 {
607 while (*++p)
608 if (!IsUserChar(*p))
609 return 0;
610 }
611
612 return p - username <= USERLEN;
613 }
614
615 /* clean_nick_name()
616 *
617 * input - nickname
618 * - whether it's a local nick (1) or remote (0)
619 * output - none
620 * side effects - walks through the nickname, returning 0 if erroneous
621 */
622 int
623 valid_nickname(const char *nickname, const int local)
624 {
625 const char *p = nickname;
626
627 assert(p);
628
629 /*
630 * Nicks can't start with a digit or - or be 0 length.
631 */
632 if (EmptyString(p) || *p == '-' || (IsDigit(*p) && local))
633 return 0;
634
635 for (; *p; ++p)
636 if (!IsNickChar(*p))
637 return 0;
638
639 return p - nickname <= NICKLEN;
640 }
641
642 /*! \brief Builds a mode change string to buffer pointed by \a buf
643 * \param client_p Pointer to client
644 * \param dispatch Whether to send a MODE message to client_p
645 * \param old Old user mode to compare against when building new mode buffer
646 * \param buf Pointer to buffer to build string in
647 */
648 void
649 send_umode(struct Client *client_p, unsigned int dispatch,
650 unsigned int old, char *buf)
651 {
652 char *m = buf;
653 int what = 0;
654
655 /*
656 * Build a string in umode_buf to represent the change in the user's
657 * mode between the new (client_p->umodes) and 'old'.
658 */
659 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
660 {
661 if ((tab->flag & old) && !HasUMode(client_p, tab->flag))
662 {
663 if (what == MODE_DEL)
664 *m++ = tab->c;
665 else
666 {
667 what = MODE_DEL;
668 *m++ = '-';
669 *m++ = tab->c;
670 }
671 }
672 else if (!(tab->flag & old) && HasUMode(client_p, tab->flag))
673 {
674 if (what == MODE_ADD)
675 *m++ = tab->c;
676 else
677 {
678 what = MODE_ADD;
679 *m++ = '+';
680 *m++ = tab->c;
681 }
682 }
683 }
684
685 *m = '\0';
686
687 if (dispatch && *buf)
688 sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
689 client_p->name, client_p->username,
690 client_p->host, client_p->name, buf);
691 }
692
693 /* send_umode_out()
694 *
695 * inputs -
696 * output - NONE
697 * side effects - Only send ubuf out to servers that know about this client
698 */
699 void
700 send_umode_out(struct Client *client_p, unsigned int old)
701 {
702 char buf[IRCD_BUFSIZE] = "";
703
704 send_umode(client_p, MyConnect(client_p), old, buf);
705
706 if (buf[0])
707 sendto_server(client_p, 0, 0, ":%s MODE %s :%s",
708 client_p->id, client_p->id, buf);
709 }
710
711 void
712 user_set_hostmask(struct Client *client_p, const char *hostname, const int what)
713 {
714 dlink_node *node = NULL;
715
716 if (!strcmp(client_p->host, hostname))
717 return;
718
719 switch (what)
720 {
721 case MODE_ADD:
722 AddUMode(client_p, UMODE_HIDDENHOST);
723 break;
724 case MODE_DEL:
725 DelUMode(client_p, UMODE_HIDDENHOST);
726 break;
727 default: return;
728 }
729
730 if (ConfigGeneral.cycle_on_host_change)
731 sendto_common_channels_local(client_p, 0, 0, CAP_CHGHOST, ":%s!%s@%s QUIT :Changing hostname",
732 client_p->name, client_p->username, client_p->host);
733
734 sendto_common_channels_local(client_p, 0, CAP_CHGHOST, 0, ":%s!%s@%s CHGHOST %s %s",
735 client_p->name, client_p->username,
736 client_p->host, client_p->username, hostname);
737
738 strlcpy(client_p->host, hostname, sizeof(client_p->host));
739
740 if (MyConnect(client_p))
741 {
742 sendto_one_numeric(client_p, &me, RPL_VISIBLEHOST, client_p->host);
743 clear_ban_cache_list(&client_p->channel);
744 }
745
746 if (!ConfigGeneral.cycle_on_host_change)
747 return;
748
749 DLINK_FOREACH(node, client_p->channel.head)
750 {
751 char modebuf[CMEMBER_STATUS_FLAGS_LEN + 1];
752 char nickbuf[CMEMBER_STATUS_FLAGS_LEN * NICKLEN + CMEMBER_STATUS_FLAGS_LEN] = "";
753 char *p = modebuf;
754 int len = 0;
755 const struct Membership *member = node->data;
756
757 if (has_member_flags(member, CHFL_CHANOP))
758 {
759 *p++ = 'o';
760 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
761 }
762
763 if (has_member_flags(member, CHFL_HALFOP))
764 {
765 *p++ = 'h';
766 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
767 }
768
769 if (has_member_flags(member, CHFL_VOICE))
770 {
771 *p++ = 'v';
772 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
773 }
774
775 *p = '\0';
776
777 sendto_channel_local(client_p, member->chptr, 0, CAP_EXTENDED_JOIN, CAP_CHGHOST, ":%s!%s@%s JOIN %s %s :%s",
778 client_p->name, client_p->username,
779 client_p->host, member->chptr->name,
780 client_p->account, client_p->info);
781 sendto_channel_local(client_p, member->chptr, 0, 0, CAP_EXTENDED_JOIN | CAP_CHGHOST, ":%s!%s@%s JOIN :%s",
782 client_p->name, client_p->username,
783 client_p->host, member->chptr->name);
784
785 if (nickbuf[0])
786 sendto_channel_local(client_p, member->chptr, 0, 0, CAP_CHGHOST, ":%s MODE %s +%s %s",
787 client_p->servptr->name, member->chptr->name,
788 modebuf, nickbuf);
789 }
790
791 if (client_p->away[0])
792 sendto_common_channels_local(client_p, 0, CAP_AWAY_NOTIFY, CAP_CHGHOST,
793 ":%s!%s@%s AWAY :%s",
794 client_p->name, client_p->username,
795 client_p->host, client_p->away);
796 }

Properties

Name Value
svn:eol-style native
svn:keywords Id