/[svn]/ircd-hybrid/trunk/src/user.c
ViewVC logotype

Contents of /ircd-hybrid/trunk/src/user.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 8255 - (show annotations)
Wed May 24 17:08:47 2017 UTC (3 years, 2 months ago) by michael
File MIME type: text/x-chdr
File size: 22977 byte(s)
- Change RPL_WELCOME to rfc2812 style now that we have the realhost information in Client::realhost

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 "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 "userhost.h"
50 #include "misc.h"
51 #include "parse.h"
52 #include "watch.h"
53 #include "isupport.h"
54 #include "tls.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 || 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_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, 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), ircd_version);
270 sendto_one_numeric(client_p, &me, RPL_CREATED, built_date);
271 sendto_one_numeric(client_p, &me, RPL_MYINFO, me.name, ircd_version, 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 int
285 check_xline(struct Client *client_p)
286 {
287 const struct GecosItem *gecos = NULL;
288
289 if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
290 return 0;
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 1;
303 }
304
305 return 0;
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(MyConnect(client_p));
320 assert(IsUnknown(client_p));
321 assert(!client_p->connection->registration);
322
323 if (ConfigGeneral.ping_cookie)
324 {
325 if (!HasFlag(client_p, FLAGS_PINGSENT) && !client_p->connection->random_ping)
326 {
327 do
328 client_p->connection->random_ping = genrand_int32();
329 while (!client_p->connection->random_ping);
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 client_p->connection->last_privmsg = CurrentTime;
341 /* Straight up the maximum rate of flooding... */
342 client_p->connection->allow_read = MAX_FLOOD_BURST;
343
344 if (!check_client(client_p))
345 return;
346
347 conf = client_p->connection->confs.head->data;
348
349 if (!HasFlag(client_p, FLAGS_GOTID))
350 {
351 char username[USERLEN + 1] = "";
352 unsigned int i = 0;
353
354 if (IsNeedIdentd(conf))
355 {
356 ++ServerStats.is_ref;
357 sendto_one_notice(client_p, &me, ":*** Notice -- You need to install "
358 "identd to use this server");
359 exit_client(client_p, "Install identd");
360 return;
361 }
362
363 strlcpy(username, client_p->username, sizeof(username));
364
365 if (!IsNoTilde(conf))
366 client_p->username[i++] = '~';
367
368 for (const char *p = username; *p && i < USERLEN; ++p)
369 client_p->username[i++] = *p;
370
371 client_p->username[i] = '\0';
372 }
373
374 /* Password check */
375 if (!EmptyString(conf->passwd))
376 {
377 if (!match_conf_password(client_p->connection->password, conf))
378 {
379 ++ServerStats.is_ref;
380
381 sendto_one_numeric(client_p, &me, ERR_PASSWDMISMATCH);
382 exit_client(client_p, "Bad Password");
383 return;
384 }
385 }
386
387 /*
388 * Don't free client_p->connection->password here - it can be required
389 * by masked /stats I if there are auth {} blocks with need_password = no;
390 * --adx
391 */
392
393 /*
394 * Report if user has &^>= etc. and set flags as needed in client_p
395 */
396 report_and_set_user_flags(client_p, conf);
397
398 if (IsDead(client_p))
399 return;
400
401 /*
402 * Limit clients -
403 * We want to be able to have servers and F-line clients
404 * connect, so save room for "buffer" connections.
405 * Smaller servers may want to decrease this, and it should
406 * probably be just a percentage of the MAXCLIENTS...
407 * -Taner
408 */
409 if ((dlink_list_length(&local_client_list) >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
410 (dlink_list_length(&local_client_list) >= GlobalSetOptions.maxclients && !HasFlag(client_p, FLAGS_NOLIMIT)))
411 {
412 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
413 "Too many clients, rejecting %s[%s].",
414 client_p->name, client_p->host);
415 ++ServerStats.is_ref;
416 exit_client(client_p, "Sorry, server is full - try later");
417 return;
418 }
419
420 if (!valid_username(client_p->username, 1))
421 {
422 char buf[IRCD_BUFSIZE] = "";
423
424 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
425 "Invalid username: %s (%s@%s)",
426 client_p->name, client_p->username, client_p->host);
427 ++ServerStats.is_ref;
428 snprintf(buf, sizeof(buf), "Invalid username [%s]", client_p->username);
429 exit_client(client_p, buf);
430 return;
431 }
432
433 if (check_xline(client_p))
434 return;
435
436 const char *id;
437 while (hash_find_id((id = uid_get())))
438 ;
439
440 strlcpy(client_p->id, id, sizeof(client_p->id));
441 hash_add_id(client_p);
442
443 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
444 "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
445 client_p->name, client_p->username, client_p->realhost,
446 client_p->sockhost,
447 get_client_class(&client_p->connection->confs),
448 client_p->info, client_p->id);
449
450 if (ConfigGeneral.invisible_on_connect)
451 {
452 AddUMode(client_p, UMODE_INVISIBLE);
453 ++Count.invisi;
454 }
455
456 assert(client_p->servptr == &me);
457 SetClient(client_p);
458 dlinkAdd(client_p, &client_p->lnode, &client_p->servptr->serv->client_list);
459 dlinkAdd(client_p, &client_p->node, &global_client_list);
460
461 assert(dlinkFind(&unknown_list, client_p));
462
463 dlink_move_node(&client_p->connection->lclient_node,
464 &unknown_list, &local_client_list);
465
466 if (dlink_list_length(&local_client_list) > Count.max_loc)
467 {
468 Count.max_loc = dlink_list_length(&local_client_list);
469
470 if (!(Count.max_loc % 10))
471 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
472 "New maximum local client connections: %u",
473 Count.max_loc);
474 }
475
476 if ((dlink_list_length(&local_client_list) +
477 dlink_list_length(&local_server_list)) > Count.max_loc_con)
478 Count.max_loc_con = dlink_list_length(&local_client_list) +
479 dlink_list_length(&local_server_list);
480
481 if (dlink_list_length(&global_client_list) > Count.max_tot)
482 Count.max_tot = dlink_list_length(&global_client_list);
483 ++Count.totalrestartcount;
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 SetClient(client_p);
515 dlinkAdd(client_p, &client_p->lnode, &client_p->servptr->serv->client_list);
516 dlinkAdd(client_p, &client_p->node, &global_client_list);
517
518 if (dlink_list_length(&global_client_list) > Count.max_tot)
519 Count.max_tot = dlink_list_length(&global_client_list);
520
521 userhost_add(client_p->sockhost, 1);
522 AddFlag(client_p, FLAGS_USERHOST);
523
524 if (HasFlag(client_p->servptr, FLAGS_EOB))
525 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
526 "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
527 client_p->servptr->name,
528 client_p->name, client_p->username, client_p->realhost,
529 client_p->sockhost, client_p->info, client_p->id);
530
531 introduce_client(client_p);
532 }
533
534 /* valid_hostname()
535 *
536 * Inputs - pointer to hostname
537 * Output - 1 if valid, 0 if not
538 * Side effects - check hostname for validity
539 *
540 * NOTE: this doesn't allow a hostname to begin with a dot and
541 * will not allow more dots than chars.
542 */
543 int
544 valid_hostname(const char *hostname)
545 {
546 const char *p = hostname;
547
548 assert(p);
549
550 if (EmptyString(p) || *p == '.' || *p == ':')
551 return 0;
552
553 for (; *p; ++p)
554 if (!IsHostChar(*p))
555 return 0;
556
557 return p - hostname <= HOSTLEN;
558 }
559
560 /* valid_username()
561 *
562 * Inputs - pointer to user
563 * Output - 1 if valid, 0 if not
564 * Side effects - check username for validity
565 *
566 * Absolutely always reject any '*' '!' '?' '@' in an user name
567 * reject any odd control characters names.
568 * Allow '.' in username to allow for "first.last"
569 * style of username
570 */
571 int
572 valid_username(const char *username, const int local)
573 {
574 const char *p = username;
575
576 assert(p);
577
578 if (*p == '~')
579 ++p;
580
581 /*
582 * Reject usernames that don't start with an alphanum
583 * i.e. reject jokers who have '-@somehost' or '.@somehost'
584 * or "-hi-@somehost", "h-----@somehost" would still be accepted.
585 */
586 if (!IsAlNum(*p))
587 return 0;
588
589 if (local)
590 {
591 unsigned int dots = 0;
592
593 while (*++p)
594 {
595 if (*p == '.' && ConfigGeneral.dots_in_ident)
596 {
597 if (++dots > ConfigGeneral.dots_in_ident)
598 return 0;
599 if (!IsUserChar(*(p + 1)))
600 return 0;
601 }
602 else if (!IsUserChar(*p))
603 return 0;
604 }
605 }
606 else
607 {
608 while (*++p)
609 if (!IsUserChar(*p))
610 return 0;
611 }
612
613 return p - username <= USERLEN;
614 }
615
616 /* clean_nick_name()
617 *
618 * input - nickname
619 * - whether it's a local nick (1) or remote (0)
620 * output - none
621 * side effects - walks through the nickname, returning 0 if erroneous
622 */
623 int
624 valid_nickname(const char *nickname, const int local)
625 {
626 const char *p = nickname;
627
628 assert(p);
629
630 /*
631 * Nicks can't start with a digit or - or be 0 length.
632 */
633 if (EmptyString(p) || *p == '-' || (IsDigit(*p) && local))
634 return 0;
635
636 for (; *p; ++p)
637 if (!IsNickChar(*p))
638 return 0;
639
640 return p - nickname <= NICKLEN;
641 }
642
643 /*! \brief Builds a mode change string to buffer pointed by \a buf
644 * \param client_p Pointer to client
645 * \param dispatch Whether to send a MODE message to client_p
646 * \param old Old user mode to compare against when building new mode buffer
647 * \param buf Pointer to buffer to build string in
648 */
649 void
650 send_umode(struct Client *client_p, unsigned int dispatch,
651 unsigned int old, char *buf)
652 {
653 char *m = buf;
654 int what = 0;
655
656 /*
657 * Build a string in umode_buf to represent the change in the user's
658 * mode between the new (client_p->umodes) and 'old'.
659 */
660 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
661 {
662 if ((tab->flag & old) && !HasUMode(client_p, tab->flag))
663 {
664 if (what == MODE_DEL)
665 *m++ = tab->c;
666 else
667 {
668 what = MODE_DEL;
669 *m++ = '-';
670 *m++ = tab->c;
671 }
672 }
673 else if (!(tab->flag & old) && HasUMode(client_p, tab->flag))
674 {
675 if (what == MODE_ADD)
676 *m++ = tab->c;
677 else
678 {
679 what = MODE_ADD;
680 *m++ = '+';
681 *m++ = tab->c;
682 }
683 }
684 }
685
686 *m = '\0';
687
688 if (dispatch && *buf)
689 sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
690 client_p->name, client_p->username,
691 client_p->host, client_p->name, buf);
692 }
693
694 /* send_umode_out()
695 *
696 * inputs -
697 * output - NONE
698 * side effects - Only send ubuf out to servers that know about this client
699 */
700 void
701 send_umode_out(struct Client *client_p, unsigned int old)
702 {
703 char buf[UMODE_MAX_STR] = "";
704
705 send_umode(client_p, MyConnect(client_p), old, buf);
706
707 if (buf[0])
708 sendto_server(client_p, 0, 0, ":%s MODE %s :%s",
709 client_p->id, client_p->id, buf);
710 }
711
712 void
713 user_set_hostmask(struct Client *client_p, const char *hostname)
714 {
715 dlink_node *node;
716
717 if (!strcmp(client_p->host, hostname))
718 return;
719
720 if (ConfigGeneral.cycle_on_host_change)
721 sendto_common_channels_local(client_p, 0, 0, CAP_CHGHOST, ":%s!%s@%s QUIT :Changing hostname",
722 client_p->name, client_p->username, client_p->host);
723
724 sendto_common_channels_local(client_p, 0, CAP_CHGHOST, 0, ":%s!%s@%s CHGHOST %s %s",
725 client_p->name, client_p->username,
726 client_p->host, client_p->username, hostname);
727
728 strlcpy(client_p->host, hostname, sizeof(client_p->host));
729
730 if (MyConnect(client_p))
731 {
732 sendto_one_numeric(client_p, &me, RPL_VISIBLEHOST, client_p->host);
733 clear_ban_cache_list(&client_p->channel);
734 }
735
736 if (!ConfigGeneral.cycle_on_host_change)
737 return;
738
739 DLINK_FOREACH(node, client_p->channel.head)
740 {
741 char modebuf[CMEMBER_STATUS_FLAGS_LEN + 1];
742 char nickbuf[CMEMBER_STATUS_FLAGS_LEN * NICKLEN + CMEMBER_STATUS_FLAGS_LEN] = "";
743 char *p = modebuf;
744 int len = 0;
745 const struct Membership *member = node->data;
746
747 if (has_member_flags(member, CHFL_CHANOP))
748 {
749 *p++ = 'o';
750 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
751 }
752
753 if (has_member_flags(member, CHFL_HALFOP))
754 {
755 *p++ = 'h';
756 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
757 }
758
759 if (has_member_flags(member, CHFL_VOICE))
760 {
761 *p++ = 'v';
762 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
763 }
764
765 *p = '\0';
766
767 sendto_channel_local(client_p, member->chptr, 0, CAP_EXTENDED_JOIN, CAP_CHGHOST, ":%s!%s@%s JOIN %s %s :%s",
768 client_p->name, client_p->username,
769 client_p->host, member->chptr->name,
770 client_p->account, client_p->info);
771 sendto_channel_local(client_p, member->chptr, 0, 0, CAP_EXTENDED_JOIN | CAP_CHGHOST, ":%s!%s@%s JOIN :%s",
772 client_p->name, client_p->username,
773 client_p->host, member->chptr->name);
774
775 if (nickbuf[0])
776 sendto_channel_local(client_p, member->chptr, 0, 0, CAP_CHGHOST, ":%s MODE %s +%s %s",
777 client_p->servptr->name, member->chptr->name,
778 modebuf, nickbuf);
779 }
780
781 if (client_p->away[0])
782 sendto_common_channels_local(client_p, 0, CAP_AWAY_NOTIFY, CAP_CHGHOST,
783 ":%s!%s@%s AWAY :%s",
784 client_p->name, client_p->username,
785 client_p->host, client_p->away);
786 }

Properties

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

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28