ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/user.c
Revision: 6307
Committed: Fri Jul 24 13:41:37 2015 UTC (8 years, 8 months ago) by michael
Content type: text/x-csrc
File size: 25231 byte(s)
Log Message:
- user.c:user_oper_up(): remove useless assert()

File Contents

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

Properties

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