/[svn]/ircd-hybrid/branches/8.2.x/src/user.c
ViewVC logotype

Contents of /ircd-hybrid/branches/8.2.x/src/user.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5564 - (show annotations)
Sat Feb 14 20:07:58 2015 UTC (5 years, 4 months ago) by michael
File MIME type: text/x-chdr
File size: 31483 byte(s)
- user.c: update documentation

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 "irc_string.h"
35 #include "ircd.h"
36 #include "listener.h"
37 #include "motd.h"
38 #include "numeric.h"
39 #include "conf.h"
40 #include "log.h"
41 #include "server.h"
42 #include "send.h"
43 #include "memory.h"
44 #include "packet.h"
45 #include "rng_mt.h"
46 #include "userhost.h"
47 #include "misc.h"
48 #include "parse.h"
49 #include "watch.h"
50
51 static char umode_buffer[IRCD_BUFSIZE];
52 static const char *uid_get(void);
53
54 /* Used for building up the isupport string,
55 * used with init_isupport, add_isupport, delete_isupport
56 */
57 struct Isupport
58 {
59 dlink_node node;
60 char *name;
61 char *options;
62 int number;
63 };
64
65 static dlink_list support_list;
66 static dlink_list support_list_lines;
67
68 const struct user_modes *umode_map[256];
69 const struct user_modes umode_tab[] =
70 {
71 { 'D', UMODE_DEAF },
72 { 'F', UMODE_FARCONNECT },
73 { 'G', UMODE_SOFTCALLERID },
74 { 'H', UMODE_HIDDEN },
75 { 'R', UMODE_REGONLY },
76 { 'S', UMODE_SSL },
77 { 'W', UMODE_WEBIRC },
78 { 'a', UMODE_ADMIN },
79 { 'b', UMODE_BOTS },
80 { 'c', UMODE_CCONN },
81 { 'd', UMODE_DEBUG },
82 { 'e', UMODE_EXTERNAL },
83 { 'f', UMODE_FULL },
84 { 'g', UMODE_CALLERID },
85 { 'i', UMODE_INVISIBLE },
86 { 'j', UMODE_REJ },
87 { 'k', UMODE_SKILL },
88 { 'l', UMODE_LOCOPS },
89 { 'n', UMODE_NCHANGE },
90 { 'o', UMODE_OPER },
91 { 'p', UMODE_HIDECHANS },
92 { 'q', UMODE_HIDEIDLE },
93 { 'r', UMODE_REGISTERED },
94 { 's', UMODE_SERVNOTICE },
95 { 'u', UMODE_UNAUTH },
96 { 'w', UMODE_WALLOP },
97 { 'x', UMODE_HIDDENHOST },
98 { 'y', UMODE_SPY },
99 { '\0', 0 }
100 };
101
102 void
103 user_usermodes_init(void)
104 {
105 char *umode_buffer_ptr = umode_buffer;
106
107 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
108 {
109 umode_map[tab->c] = tab;
110 *umode_buffer_ptr++ = tab->c;
111 }
112
113 *umode_buffer_ptr = '\0';
114 }
115
116 /* show_lusers()
117 *
118 * inputs - pointer to client
119 * output - NONE
120 * side effects - display to client user counts etc.
121 */
122 void
123 show_lusers(struct Client *source_p)
124 {
125 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
126 sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
127 Count.invisi, dlink_list_length(&global_server_list));
128 else
129 sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
130 Count.invisi, 1);
131
132 if (Count.oper)
133 sendto_one_numeric(source_p, &me, RPL_LUSEROP, Count.oper);
134
135 if (dlink_list_length(&unknown_list))
136 sendto_one_numeric(source_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
137
138 if (dlink_list_length(&channel_list))
139 sendto_one_numeric(source_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&channel_list));
140
141 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
142 {
143 sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.local, Count.myserver);
144 sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
145 }
146 else
147 {
148 sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.total, 0);
149 sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
150 }
151
152 sendto_one_numeric(source_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
153
154 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
155 sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
156 Count.max_loc_cli, Count.totalrestartcount);
157
158 if (Count.local > Count.max_loc_cli)
159 Count.max_loc_cli = Count.local;
160
161 if ((Count.local + Count.myserver) > Count.max_loc_con)
162 Count.max_loc_con = Count.local + Count.myserver;
163 }
164
165 /* show_isupport()
166 *
167 * inputs - pointer to client
168 * output - NONE
169 * side effects - display to client what we support (for them)
170 */
171 void
172 show_isupport(struct Client *source_p)
173 {
174 const dlink_node *node = NULL;
175
176 DLINK_FOREACH(node, support_list_lines.head)
177 sendto_one_numeric(source_p, &me, RPL_ISUPPORT, node->data);
178 }
179
180
181 /* report_and_set_user_flags()
182 *
183 * inputs - pointer to source_p
184 * - pointer to conf for this user
185 * output - NONE
186 * side effects - Report to user any special flags
187 * they are getting, and set them.
188 */
189 static void
190 report_and_set_user_flags(struct Client *source_p, const struct MaskItem *conf)
191 {
192 /* If this user is being spoofed, tell them so */
193 if (IsConfDoSpoofIp(conf))
194 sendto_one_notice(source_p, &me, ":*** Spoofing your IP. Congrats.");
195
196 /* If this user is in the exception class, set it "E lined" */
197 if (IsConfExemptKline(conf))
198 {
199 SetExemptKline(source_p);
200 sendto_one_notice(source_p, &me, ":*** You are exempt from K/D/G lines. Congrats.");
201 }
202
203 /*
204 * The else here is to make sure that G line exempt users
205 * do not get noticed twice.
206 */
207 else if (IsConfExemptGline(conf))
208 {
209 SetExemptGline(source_p);
210 sendto_one_notice(source_p, &me, ":*** You are exempt from G lines. Congrats.");
211 }
212
213 if (IsConfExemptResv(conf))
214 {
215 SetExemptResv(source_p);
216 sendto_one_notice(source_p, &me, ":*** You are exempt from resvs. Congrats.");
217 }
218
219 /* If this user is exempt from user limits set it "F lined" */
220 if (IsConfExemptLimits(conf))
221 {
222 SetExemptLimits(source_p);
223 sendto_one_notice(source_p, &me, ":*** You are exempt from user limits. Congrats.");
224 }
225
226 if (IsConfCanFlood(conf))
227 {
228 SetCanFlood(source_p);
229 sendto_one_notice(source_p, &me, ":*** You are exempt from flood "
230 "protection, aren't you fearsome.");
231 }
232 }
233
234 /* introduce_client()
235 *
236 * inputs - source_p
237 * output - NONE
238 * side effects - This common function introduces a client to the rest
239 * of the net, either from a local client connect or
240 * from a remote connect.
241 */
242 static void
243 introduce_client(struct Client *source_p)
244 {
245 dlink_node *node = NULL;
246 char ubuf[IRCD_BUFSIZE] = "";
247
248 if (MyClient(source_p))
249 send_umode(source_p, source_p, 0, ubuf);
250 else
251 send_umode(NULL, source_p, 0, ubuf);
252
253 watch_check_hash(source_p, RPL_LOGON);
254
255 if (ubuf[0] == '\0')
256 {
257 ubuf[0] = '+';
258 ubuf[1] = '\0';
259 }
260
261 DLINK_FOREACH(node, local_server_list.head)
262 {
263 struct Client *server = node->data;
264
265 if (server == source_p->from)
266 continue;
267
268 if (IsCapable(server, CAP_SVS))
269 sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s %s :%s",
270 source_p->servptr->id,
271 source_p->name, source_p->hopcount+1,
272 (unsigned long)source_p->tsinfo,
273 ubuf, source_p->username, source_p->host,
274 source_p->sockhost, source_p->id,
275 source_p->account,
276 source_p->info);
277 else
278 sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s :%s",
279 source_p->servptr->id,
280 source_p->name, source_p->hopcount+1,
281 (unsigned long)source_p->tsinfo,
282 ubuf, source_p->username, source_p->host,
283 source_p->sockhost, source_p->id, source_p->info);
284
285 if (!EmptyString(source_p->certfp))
286 sendto_one(server, ":%s CERTFP %s", source_p->id, source_p->certfp);
287 }
288 }
289
290 /* user_welcome()
291 *
292 * inputs - client pointer to client to welcome
293 * output - NONE
294 * side effects -
295 */
296 static void
297 user_welcome(struct Client *source_p)
298 {
299 #if defined(__TIME__) && defined(__DATE__)
300 static const char built_date[] = __DATE__ " at " __TIME__;
301 #else
302 static const char built_date[] = "unknown";
303 #endif
304
305 #ifdef HAVE_LIBCRYPTO
306 if (HasFlag(source_p, FLAGS_SSL))
307 {
308 AddUMode(source_p, UMODE_SSL);
309 sendto_one_notice(source_p, &me, ":*** Connected securely via %s",
310 ssl_get_cipher(source_p->connection->fd.ssl));
311 }
312 #endif
313
314 sendto_one_numeric(source_p, &me, RPL_WELCOME, ConfigServerInfo.network_name,
315 source_p->name);
316 sendto_one_numeric(source_p, &me, RPL_YOURHOST,
317 get_listener_name(source_p->connection->listener), ircd_version);
318 sendto_one_numeric(source_p, &me, RPL_CREATED, built_date);
319 sendto_one_numeric(source_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
320 show_isupport(source_p);
321 sendto_one_numeric(source_p, &me, RPL_YOURID, source_p->id);
322
323 show_lusers(source_p);
324 motd_signon(source_p);
325 }
326
327 /* check_xline()
328 *
329 * inputs - pointer to client to test
330 * outupt - 1 if exiting 0 if ok
331 * side effects -
332 */
333 static int
334 check_xline(struct Client *source_p)
335 {
336 struct MaskItem *conf = NULL;
337
338 if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
339 {
340 ++conf->count;
341 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
342 "X-line Rejecting [%s] [%s], user %s [%s]",
343 source_p->info, conf->reason,
344 get_client_name(source_p, HIDE_IP),
345 source_p->sockhost);
346
347 ++ServerStats.is_ref;
348 exit_client(source_p, "Bad user info");
349 return 1;
350 }
351
352 return 0;
353 }
354
355 /*! \brief This function is called when both NICK and USER messages
356 * have been accepted for the client, in whatever order. Only
357 * after this, is the UID message propagated.
358 * \param source_p Pointer to given client to introduce
359 */
360 void
361 register_local_user(struct Client *source_p)
362 {
363 const char *id = NULL;
364 const struct MaskItem *conf = NULL;
365
366 assert(source_p == source_p->from);
367 assert(MyConnect(source_p));
368 assert(!source_p->connection->registration);
369
370 if (ConfigGeneral.ping_cookie)
371 {
372 if (!IsPingSent(source_p) && !source_p->connection->random_ping)
373 {
374 do
375 source_p->connection->random_ping = genrand_int32();
376 while (!source_p->connection->random_ping);
377
378 sendto_one(source_p, "PING :%u", source_p->connection->random_ping);
379 SetPingSent(source_p);
380 return;
381 }
382
383 if (!HasPingCookie(source_p))
384 return;
385 }
386
387 source_p->connection->last_privmsg = CurrentTime;
388 /* Straight up the maximum rate of flooding... */
389 source_p->connection->allow_read = MAX_FLOOD_BURST;
390
391 if (!check_client(source_p))
392 return;
393
394 if (!valid_hostname(source_p->host))
395 {
396 sendto_one_notice(source_p, &me, ":*** Notice -- You have an illegal "
397 "character in your hostname");
398 strlcpy(source_p->host, source_p->sockhost, sizeof(source_p->host));
399 }
400
401 conf = source_p->connection->confs.head->data;
402
403 if (!IsGotId(source_p))
404 {
405 char username[USERLEN + 1] = "";
406 const char *p = username;
407 unsigned int i = 0;
408
409 if (IsNeedIdentd(conf))
410 {
411 ++ServerStats.is_ref;
412 sendto_one_notice(source_p, &me, ":*** Notice -- You need to install "
413 "identd to use this server");
414 exit_client(source_p, "Install identd");
415 return;
416 }
417
418 strlcpy(username, source_p->username, sizeof(username));
419
420 if (!IsNoTilde(conf))
421 source_p->username[i++] = '~';
422
423 for (; *p && i < USERLEN; ++p)
424 source_p->username[i++] = *p;
425
426 source_p->username[i] = '\0';
427 }
428
429 /* Password check */
430 if (!EmptyString(conf->passwd))
431 {
432 if (!match_conf_password(source_p->connection->password, conf))
433 {
434 ++ServerStats.is_ref;
435
436 sendto_one_numeric(source_p, &me, ERR_PASSWDMISMATCH);
437 exit_client(source_p, "Bad Password");
438 return;
439 }
440 }
441
442 /*
443 * Don't free source_p->connection->password here - it can be required
444 * by masked /stats I if there are auth {} blocks with need_password = no;
445 * --adx
446 */
447
448 /*
449 * Report if user has &^>= etc. and set flags as needed in source_p
450 */
451 report_and_set_user_flags(source_p, conf);
452
453 if (IsDead(source_p))
454 return;
455
456 /*
457 * Limit clients -
458 * We want to be able to have servers and F-line clients
459 * connect, so save room for "buffer" connections.
460 * Smaller servers may want to decrease this, and it should
461 * probably be just a percentage of the MAXCLIENTS...
462 * -Taner
463 */
464 if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
465 (Count.local >= GlobalSetOptions.maxclients && !IsExemptLimits(source_p)))
466 {
467 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
468 "Too many clients, rejecting %s[%s].",
469 source_p->name, source_p->host);
470 ++ServerStats.is_ref;
471 exit_client(source_p, "Sorry, server is full - try later");
472 return;
473 }
474
475 if (!valid_username(source_p->username, 1))
476 {
477 char buf[IRCD_BUFSIZE] = "";
478
479 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
480 "Invalid username: %s (%s@%s)",
481 source_p->name, source_p->username, source_p->host);
482 ++ServerStats.is_ref;
483 snprintf(buf, sizeof(buf), "Invalid username [%s]", source_p->username);
484 exit_client(source_p, buf);
485 return;
486 }
487
488 if (check_xline(source_p))
489 return;
490
491 while (hash_find_id((id = uid_get())))
492 ;
493
494 strlcpy(source_p->id, id, sizeof(source_p->id));
495 hash_add_id(source_p);
496
497 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
498 "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
499 source_p->name, source_p->username, source_p->host,
500 source_p->sockhost,
501 get_client_class(&source_p->connection->confs),
502 source_p->info, source_p->id);
503
504 if (ConfigGeneral.invisible_on_connect)
505 {
506 AddUMode(source_p, UMODE_INVISIBLE);
507 ++Count.invisi;
508 }
509
510 if (++Count.local > Count.max_loc)
511 {
512 Count.max_loc = Count.local;
513
514 if (!(Count.max_loc % 10))
515 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
516 "New maximum local client connections: %u",
517 Count.max_loc);
518 }
519
520 if (++Count.total > Count.max_tot)
521 Count.max_tot = Count.total;
522 ++Count.totalrestartcount;
523
524 assert(source_p->servptr == &me);
525 SetClient(source_p);
526 dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
527 dlinkAdd(source_p, &source_p->node, &global_client_list);
528
529 assert(dlinkFind(&unknown_list, source_p));
530
531 dlink_move_node(&source_p->connection->lclient_node,
532 &unknown_list, &local_client_list);
533
534 user_welcome(source_p);
535 add_user_host(source_p->username, source_p->host, 0);
536 SetUserHost(source_p);
537
538 introduce_client(source_p);
539 }
540
541 /* register_remote_user()
542 *
543 * inputs - source_p remote or directly connected client
544 * - username to register as
545 * - host name to register as
546 * - server name
547 * output - NONE
548 * side effects - This function is called when a remote client
549 * is introduced by a server.
550 */
551 void
552 register_remote_user(struct Client *source_p)
553 {
554 const struct Client *target_p = NULL;
555
556 if ((target_p = source_p->servptr) && target_p->from != source_p->from)
557 {
558 sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
559 "Bad User [%s] :%s USER %s@%s %s, != %s[%s]",
560 source_p->from->name, source_p->name, source_p->username,
561 source_p->host, source_p->servptr->name,
562 target_p->name, target_p->from->name);
563 sendto_one(source_p->from,
564 ":%s KILL %s :%s (UID from wrong direction (%s != %s))",
565 me.id, source_p->id, me.name, source_p->servptr->name,
566 target_p->from->name);
567
568 AddFlag(source_p, FLAGS_KILLED);
569 exit_client(source_p, "UID server wrong direction");
570 return;
571 }
572
573 /*
574 * If the nick has been introduced by a services server,
575 * make it a service as well.
576 */
577 if (HasFlag(source_p->servptr, FLAGS_SERVICE))
578 AddFlag(source_p, FLAGS_SERVICE);
579
580 if (++Count.total > Count.max_tot)
581 Count.max_tot = Count.total;
582
583 SetClient(source_p);
584 dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
585 dlinkAdd(source_p, &source_p->node, &global_client_list);
586 add_user_host(source_p->username, source_p->host, 1);
587 SetUserHost(source_p);
588
589 if (HasFlag(source_p->servptr, FLAGS_EOB))
590 {
591 if (strcmp(source_p->sockhost, "0")) /* XXX: TBR */
592 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
593 "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
594 source_p->servptr->name,
595 source_p->name, source_p->username, source_p->host,
596 source_p->sockhost, source_p->info, source_p->id);
597 else
598 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
599 "Client connecting at %s: %s (%s@%s) [%s] <%s>",
600 source_p->servptr->name,
601 source_p->name, source_p->username, source_p->host,
602 source_p->info, source_p->id);
603 }
604
605 introduce_client(source_p);
606 }
607
608 /* valid_hostname()
609 *
610 * Inputs - pointer to hostname
611 * Output - 1 if valid, 0 if not
612 * Side effects - check hostname for validity
613 *
614 * NOTE: this doesn't allow a hostname to begin with a dot and
615 * will not allow more dots than chars.
616 */
617 int
618 valid_hostname(const char *hostname)
619 {
620 const char *p = hostname;
621
622 assert(p);
623
624 if (EmptyString(p) || *p == '.' || *p == ':')
625 return 0;
626
627 for (; *p; ++p)
628 if (!IsHostChar(*p))
629 return 0;
630
631 return p - hostname <= HOSTLEN;
632 }
633
634 /* valid_username()
635 *
636 * Inputs - pointer to user
637 * Output - 1 if valid, 0 if not
638 * Side effects - check username for validity
639 *
640 * Absolutely always reject any '*' '!' '?' '@' in an user name
641 * reject any odd control characters names.
642 * Allow '.' in username to allow for "first.last"
643 * style of username
644 */
645 int
646 valid_username(const char *username, const int local)
647 {
648 unsigned int dots = 0;
649 const char *p = username;
650
651 assert(p);
652
653 if (*p == '~')
654 ++p;
655
656 /*
657 * Reject usernames that don't start with an alphanum
658 * i.e. reject jokers who have '-@somehost' or '.@somehost'
659 * or "-hi-@somehost", "h-----@somehost" would still be accepted.
660 */
661 if (!IsAlNum(*p))
662 return 0;
663
664 if (local)
665 {
666 while (*++p)
667 {
668 if (*p == '.' && ConfigGeneral.dots_in_ident)
669 {
670 if (++dots > ConfigGeneral.dots_in_ident)
671 return 0;
672 if (!IsUserChar(*(p + 1)))
673 return 0;
674 }
675 else if (!IsUserChar(*p))
676 return 0;
677 }
678 }
679 else
680 {
681 while (*++p)
682 if (!IsUserChar(*p))
683 return 0;
684 }
685
686 return p - username <= USERLEN;
687 }
688
689 /* clean_nick_name()
690 *
691 * input - nickname
692 * - whether it's a local nick (1) or remote (0)
693 * output - none
694 * side effects - walks through the nickname, returning 0 if erroneous
695 */
696 int
697 valid_nickname(const char *nickname, const int local)
698 {
699 const char *p = nickname;
700
701 assert(p);
702
703 /*
704 * Nicks can't start with a digit or - or be 0 length.
705 */
706 if (EmptyString(p) || *p == '-' || (IsDigit(*p) && local))
707 return 0;
708
709 for (; *p; ++p)
710 if (!IsNickChar(*p))
711 return 0;
712
713 return p - nickname <= NICKLEN;
714 }
715
716 /* send_umode()
717 * send the MODE string for user (user) to connection client_p
718 * -avalon
719 *
720 * inputs - client_p
721 * - source_p
722 * - int old
723 * - sendmask mask of modes to send
724 * - suplied umode_buf
725 * output - NONE
726 */
727 void
728 send_umode(struct Client *client_p, struct Client *source_p,
729 unsigned int old, char *umode_buf)
730 {
731 char *m = umode_buf;
732 int what = 0;
733
734 /*
735 * Build a string in umode_buf to represent the change in the user's
736 * mode between the new (source_p->umodes) and 'old'.
737 */
738 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
739 {
740 if ((tab->flag & old) && !HasUMode(source_p, tab->flag))
741 {
742 if (what == MODE_DEL)
743 *m++ = tab->c;
744 else
745 {
746 what = MODE_DEL;
747 *m++ = '-';
748 *m++ = tab->c;
749 }
750 }
751 else if (!(tab->flag & old) && HasUMode(source_p, tab->flag))
752 {
753 if (what == MODE_ADD)
754 *m++ = tab->c;
755 else
756 {
757 what = MODE_ADD;
758 *m++ = '+';
759 *m++ = tab->c;
760 }
761 }
762 }
763
764 *m = '\0';
765
766 if (*umode_buf && client_p)
767 sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
768 client_p->name, client_p->username,
769 client_p->host, client_p->name, umode_buf);
770 }
771
772 /* send_umode_out()
773 *
774 * inputs -
775 * output - NONE
776 * side effects - Only send ubuf out to servers that know about this client
777 */
778 void
779 send_umode_out(struct Client *source_p, unsigned int old)
780 {
781 char buf[IRCD_BUFSIZE] = "";
782
783 send_umode(MyClient(source_p) ? source_p : NULL, source_p, old, buf);
784
785 if (buf[0])
786 sendto_server(source_p, 0, 0, ":%s MODE %s :%s",
787 source_p->id, source_p->id, buf);
788 }
789
790 void
791 user_set_hostmask(struct Client *target_p, const char *hostname, const int what)
792 {
793 dlink_node *node = NULL;
794
795 if (!strcmp(target_p->host, hostname))
796 return;
797
798 switch (what)
799 {
800 case MODE_ADD:
801 AddUMode(target_p, UMODE_HIDDENHOST);
802 break;
803 case MODE_DEL:
804 DelUMode(target_p, UMODE_HIDDENHOST);
805 break;
806 default: return;
807 }
808
809 if (ConfigGeneral.cycle_on_host_change)
810 sendto_common_channels_local(target_p, 0, 0, ":%s!%s@%s QUIT :Changing hostname",
811 target_p->name, target_p->username, target_p->host);
812
813 if (IsUserHostIp(target_p))
814 delete_user_host(target_p->username, target_p->host, !MyConnect(target_p));
815
816 strlcpy(target_p->host, hostname, sizeof(target_p->host));
817
818 add_user_host(target_p->username, target_p->host, !MyConnect(target_p));
819 SetUserHost(target_p);
820
821 if (MyClient(target_p))
822 {
823 sendto_one_numeric(target_p, &me, RPL_VISIBLEHOST, target_p->host);
824 clear_ban_cache_client(target_p);
825 }
826
827 if (!ConfigGeneral.cycle_on_host_change)
828 return;
829
830 DLINK_FOREACH(node, target_p->channel.head)
831 {
832 char modebuf[4], nickbuf[NICKLEN * 3 + 3] = "";
833 char *p = modebuf;
834 int len = 0;
835 const struct Membership *member = node->data;
836
837 if (has_member_flags(member, CHFL_CHANOP))
838 {
839 *p++ = 'o';
840 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
841 }
842
843 if (has_member_flags(member, CHFL_HALFOP))
844 {
845 *p++ = 'h';
846 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
847 }
848
849 if (has_member_flags(member, CHFL_VOICE))
850 {
851 *p++ = 'v';
852 len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
853 }
854
855 *p = '\0';
856
857
858 sendto_channel_local_butone(target_p, CAP_EXTENDED_JOIN, 0, member->chptr, ":%s!%s@%s JOIN %s %s :%s",
859 target_p->name, target_p->username,
860 target_p->host, member->chptr->name,
861 (!IsDigit(target_p->account[0]) && target_p->account[0] != '*') ? target_p->account : "*",
862 target_p->info);
863 sendto_channel_local_butone(target_p, 0, CAP_EXTENDED_JOIN, member->chptr, ":%s!%s@%s JOIN :%s",
864 target_p->name, target_p->username,
865 target_p->host, member->chptr->name);
866
867 if (nickbuf[0])
868 sendto_channel_local_butone(target_p, 0, 0, member->chptr, ":%s MODE %s +%s %s",
869 target_p->servptr->name, member->chptr->name,
870 modebuf, nickbuf);
871
872 }
873
874 if (target_p->away[0])
875 sendto_common_channels_local(target_p, 0, CAP_AWAY_NOTIFY,
876 ":%s!%s@%s AWAY :%s",
877 target_p->name, target_p->username,
878 target_p->host, target_p->away);
879 }
880
881 /*! \brief Blindly opers up given source_p, using conf info.
882 * All checks on passwords have already been done.
883 * \param source_p Pointer to given client to oper
884 */
885 void
886 oper_up(struct Client *source_p)
887 {
888 const unsigned int old = source_p->umodes;
889 const struct MaskItem *const conf = source_p->connection->confs.head->data;
890
891 assert(source_p->connection->confs.head);
892
893 ++Count.oper;
894 SetOper(source_p);
895
896 if (conf->modes)
897 AddUMode(source_p, conf->modes);
898 else if (ConfigGeneral.oper_umodes)
899 AddUMode(source_p, ConfigGeneral.oper_umodes);
900
901 if (!(old & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
902 ++Count.invisi;
903 if ((old & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
904 --Count.invisi;
905
906 assert(dlinkFind(&oper_list, source_p) == NULL);
907 dlinkAdd(source_p, make_dlink_node(), &oper_list);
908
909 AddOFlag(source_p, conf->port);
910
911 if (HasOFlag(source_p, OPER_FLAG_ADMIN))
912 AddUMode(source_p, UMODE_ADMIN);
913
914 if (!EmptyString(conf->whois))
915 {
916 client_attach_svstag(source_p, RPL_WHOISOPERATOR, "+", conf->whois);
917 sendto_server(source_p, 0, 0, ":%s SVSTAG %s %lu %u + :%s",
918 me.id, source_p->id, (unsigned long)source_p->tsinfo,
919 RPL_WHOISOPERATOR, conf->whois);
920 }
921
922 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s is now an operator",
923 get_oper_name(source_p));
924 sendto_server(NULL, 0, 0, ":%s GLOBOPS :%s is now an operator",
925 me.id, get_oper_name(source_p));
926 send_umode_out(source_p, old);
927 sendto_one_numeric(source_p, &me, RPL_YOUREOPER);
928 }
929
930 static char new_uid[TOTALSIDUID + 1]; /* Allow for \0 */
931
932 int
933 valid_sid(const char *sid)
934 {
935 if (strlen(sid) == IRC_MAXSID)
936 if (IsDigit(*sid))
937 if (IsAlNum(*(sid + 1)) && IsAlNum(*(sid + 2)))
938 return 1;
939
940 return 0;
941 }
942
943 /*
944 * init_uid()
945 *
946 * inputs - NONE
947 * output - NONE
948 * side effects - new_uid is filled in with server id portion (sid)
949 * (first 3 bytes) or defaulted to 'A'.
950 * Rest is filled in with 'A'
951 */
952 void
953 init_uid(void)
954 {
955 memset(new_uid, 0, sizeof(new_uid));
956
957 if (!EmptyString(ConfigServerInfo.sid))
958 strlcpy(new_uid, ConfigServerInfo.sid, sizeof(new_uid));
959
960 for (unsigned int i = 0; i < IRC_MAXSID; ++i)
961 if (new_uid[i] == '\0')
962 new_uid[i] = 'A';
963
964 /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
965 memcpy(new_uid + IRC_MAXSID, "AAAAA@", IRC_MAXUID);
966 }
967
968 /*
969 * add_one_to_uid
970 *
971 * inputs - index number into new_uid
972 * output - NONE
973 * side effects - new_uid is incremented by one
974 * note this is a recursive function
975 */
976 static void
977 add_one_to_uid(unsigned int i)
978 {
979 if (i != IRC_MAXSID) /* Not reached server SID portion yet? */
980 {
981 if (new_uid[i] == 'Z')
982 new_uid[i] = '0';
983 else if (new_uid[i] == '9')
984 {
985 new_uid[i] = 'A';
986 add_one_to_uid(i - 1);
987 }
988 else
989 ++new_uid[i];
990 }
991 else
992 {
993 /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
994 if (new_uid[i] == 'Z')
995 memcpy(new_uid + IRC_MAXSID, "AAAAAA", IRC_MAXUID);
996 else
997 ++new_uid[i];
998 }
999 }
1000
1001 /*
1002 * uid_get
1003 *
1004 * inputs - struct Client *
1005 * output - new UID is returned to caller
1006 * side effects - new_uid is incremented by one.
1007 */
1008 static const char *
1009 uid_get(void)
1010 {
1011 add_one_to_uid(TOTALSIDUID - 1); /* Index from 0 */
1012 return new_uid;
1013 }
1014
1015 /*
1016 * init_isupport()
1017 *
1018 * input - NONE
1019 * output - NONE
1020 * side effects - Must be called before isupport is enabled
1021 */
1022 void
1023 init_isupport(void)
1024 {
1025 add_isupport("CALLERID", NULL, -1);
1026 add_isupport("CASEMAPPING", "rfc1459", -1);
1027 add_isupport("DEAF", "D", -1);
1028 add_isupport("KICKLEN", NULL, KICKLEN);
1029 add_isupport("MODES", NULL, MAXMODEPARAMS);
1030 add_isupport("PREFIX", "(ohv)@%+", -1);
1031 add_isupport("STATUSMSG", "@%+", -1);
1032 add_isupport("EXCEPTS", NULL, -1);
1033 add_isupport("INVEX", NULL, -1);
1034 }
1035
1036 /*
1037 * add_isupport()
1038 *
1039 * input - name of supported function
1040 * - options if any
1041 * - number if any
1042 * output - NONE
1043 * side effects - Each supported item must call this when activated
1044 */
1045 void
1046 add_isupport(const char *name, const char *options, int n)
1047 {
1048 dlink_node *node = NULL;
1049 struct Isupport *support = NULL;
1050
1051 DLINK_FOREACH(node, support_list.head)
1052 {
1053 support = node->data;
1054 if (irccmp(support->name, name) == 0)
1055 {
1056 MyFree(support->name);
1057 MyFree(support->options);
1058 break;
1059 }
1060 }
1061
1062 if (node == NULL)
1063 {
1064 support = MyCalloc(sizeof(*support));
1065 dlinkAddTail(support, &support->node, &support_list);
1066 }
1067
1068 support->name = xstrdup(name);
1069 if (options)
1070 support->options = xstrdup(options);
1071 support->number = n;
1072
1073 rebuild_isupport_message_line();
1074 }
1075
1076 /*
1077 * delete_isupport()
1078 *
1079 * input - name of supported function
1080 * output - NONE
1081 * side effects - Each supported item must call this when deactivated
1082 */
1083 void
1084 delete_isupport(const char *name)
1085 {
1086 dlink_node *node = NULL;
1087
1088 DLINK_FOREACH(node, support_list.head)
1089 {
1090 struct Isupport *support = node->data;
1091
1092 if (irccmp(support->name, name) == 0)
1093 {
1094 dlinkDelete(node, &support_list);
1095 MyFree(support->name);
1096 MyFree(support->options);
1097 MyFree(support);
1098 break;
1099 }
1100 }
1101
1102 rebuild_isupport_message_line();
1103 }
1104
1105 /*
1106 * rebuild_isupport_message_line
1107 *
1108 * input - NONE
1109 * output - NONE
1110 * side effects - Destroy the isupport MessageFile lines, and rebuild.
1111 */
1112 void
1113 rebuild_isupport_message_line(void)
1114 {
1115 char isupportbuffer[IRCD_BUFSIZE];
1116 char *p = isupportbuffer;
1117 dlink_node *node = NULL, *node_next = NULL;
1118 int n = 0;
1119 int tokens = 0;
1120 size_t len = 0;
1121 size_t reserve = strlen(me.name) + HOSTLEN + strlen(numeric_form(RPL_ISUPPORT));
1122
1123 DLINK_FOREACH_SAFE(node, node_next, support_list_lines.head)
1124 {
1125 dlinkDelete(node, &support_list_lines);
1126 MyFree(node->data);
1127 free_dlink_node(node);
1128 }
1129
1130 DLINK_FOREACH(node, support_list.head)
1131 {
1132 struct Isupport *support = node->data;
1133
1134 p += (n = sprintf(p, "%s", support->name));
1135 len += n;
1136
1137 if (support->options)
1138 {
1139 p += (n = sprintf(p, "=%s", support->options));
1140 len += n;
1141 }
1142
1143 if (support->number > 0)
1144 {
1145 p += (n = sprintf(p, "=%d", support->number));
1146 len += n;
1147 }
1148
1149 *p++ = ' ';
1150 len++;
1151 *p = '\0';
1152
1153 if (++tokens == (MAXPARA-2) || len >= (sizeof(isupportbuffer)-reserve))
1154 { /* arbritrary for now */
1155 if (*--p == ' ')
1156 *p = '\0';
1157
1158 dlinkAddTail(xstrdup(isupportbuffer), make_dlink_node(), &support_list_lines);
1159 p = isupportbuffer;
1160 len = 0;
1161 n = tokens = 0;
1162 }
1163 }
1164
1165 if (len)
1166 {
1167 if (*--p == ' ')
1168 *p = '\0';
1169 dlinkAddTail(xstrdup(isupportbuffer), make_dlink_node(), &support_list_lines);
1170 }
1171 }

Properties

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

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