ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/user.c
Revision: 8907
Committed: Sun Apr 21 21:17:44 2019 UTC (4 years, 11 months ago) by michael
Content type: text/x-csrc
File size: 22839 byte(s)
Log Message:
- Use monotonic time for client->connection->last_privmsg

File Contents

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

Properties

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