/[svn]/ircd-hybrid-8/src/conf.c
ViewVC logotype

Contents of /ircd-hybrid-8/src/conf.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1324 - (show annotations)
Fri Mar 30 21:40:38 2012 UTC (7 years, 9 months ago) by michael
File MIME type: text/x-chdr
File size: 99901 byte(s)
- Remove log::timestamp configuration directive. Timestamps are now enabled by default.
- Timestamps are iso8601 now

1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * conf.c: Configuration file functions.
4 *
5 * Copyright (C) 2002 by the past and present ircd coders, and others.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 * USA
21 *
22 * $Id$
23 */
24
25 #include "stdinc.h"
26 #include "list.h"
27 #include "ircd_defs.h"
28 #include "balloc.h"
29 #include "conf.h"
30 #include "s_serv.h"
31 #include "resv.h"
32 #include "channel.h"
33 #include "client.h"
34 #include "event.h"
35 #include "hash.h"
36 #include "hook.h"
37 #include "irc_string.h"
38 #include "sprintf_irc.h"
39 #include "s_bsd.h"
40 #include "ircd.h"
41 #include "listener.h"
42 #include "hostmask.h"
43 #include "modules.h"
44 #include "numeric.h"
45 #include "fdlist.h"
46 #include "log.h"
47 #include "send.h"
48 #include "s_gline.h"
49 #include "fileio.h"
50 #include "memory.h"
51 #include "irc_res.h"
52 #include "userhost.h"
53 #include "s_user.h"
54 #include "channel_mode.h"
55 #include "parse.h"
56 #include "s_misc.h"
57
58 struct Callback *client_check_cb = NULL;
59 struct config_server_hide ConfigServerHide;
60
61 /* general conf items link list root, other than k lines etc. */
62 dlink_list service_items = { NULL, NULL, 0 };
63 dlink_list server_items = { NULL, NULL, 0 };
64 dlink_list cluster_items = { NULL, NULL, 0 };
65 dlink_list hub_items = { NULL, NULL, 0 };
66 dlink_list leaf_items = { NULL, NULL, 0 };
67 dlink_list oconf_items = { NULL, NULL, 0 };
68 dlink_list uconf_items = { NULL, NULL, 0 };
69 dlink_list xconf_items = { NULL, NULL, 0 };
70 dlink_list rxconf_items = { NULL, NULL, 0 };
71 dlink_list rkconf_items = { NULL, NULL, 0 };
72 dlink_list nresv_items = { NULL, NULL, 0 };
73 dlink_list class_items = { NULL, NULL, 0 };
74 dlink_list gdeny_items = { NULL, NULL, 0 };
75
76 dlink_list temporary_klines = { NULL, NULL, 0 };
77 dlink_list temporary_dlines = { NULL, NULL, 0 };
78 dlink_list temporary_xlines = { NULL, NULL, 0 };
79 dlink_list temporary_rklines = { NULL, NULL, 0 };
80 dlink_list temporary_glines = { NULL, NULL, 0 };
81 dlink_list temporary_rxlines = { NULL, NULL, 0 };
82 dlink_list temporary_resv = { NULL, NULL, 0 };
83
84 extern unsigned int lineno;
85 extern char linebuf[];
86 extern char conffilebuf[IRCD_BUFSIZE];
87 extern char yytext[];
88 extern int yyparse(); /* defined in y.tab.c */
89
90 struct conf_parser_context conf_parser_ctx = { 0, 0, NULL };
91
92 /* internally defined functions */
93 static void lookup_confhost(struct ConfItem *);
94 static void set_default_conf(void);
95 static void validate_conf(void);
96 static void read_conf(FBFILE *);
97 static void clear_out_old_conf(void);
98 static void flush_deleted_I_P(void);
99 static void expire_tklines(dlink_list *);
100 static void garbage_collect_ip_entries(void);
101 static int hash_ip(struct irc_ssaddr *);
102 static int verify_access(struct Client *, const char *);
103 static int attach_iline(struct Client *, struct ConfItem *);
104 static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
105 static void parse_conf_file(int, int);
106 static dlink_list *map_to_list(ConfType);
107 static struct AccessItem *find_regexp_kline(const char *[]);
108 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
109
110 /*
111 * bit_len
112 */
113 static int cidr_limit_reached(int, struct irc_ssaddr *, struct ClassItem *);
114 static void remove_from_cidr_check(struct irc_ssaddr *, struct ClassItem *);
115 static void destroy_cidr_class(struct ClassItem *);
116
117 static void flags_to_ascii(unsigned int, const unsigned int[], char *, int);
118
119 /* address of default class conf */
120 static struct ConfItem *class_default;
121
122 /* usually, with hash tables, you use a prime number...
123 * but in this case I am dealing with ip addresses,
124 * not ascii strings.
125 */
126 #define IP_HASH_SIZE 0x1000
127
128 struct ip_entry
129 {
130 struct irc_ssaddr ip;
131 int count;
132 time_t last_attempt;
133 struct ip_entry *next;
134 };
135
136 static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
137 static BlockHeap *ip_entry_heap = NULL;
138 static int ip_entries_count = 0;
139
140
141 void *
142 map_to_conf(struct ConfItem *aconf)
143 {
144 void *conf;
145 conf = (void *)((uintptr_t)aconf +
146 (uintptr_t)sizeof(struct ConfItem));
147 return(conf);
148 }
149
150 struct ConfItem *
151 unmap_conf_item(void *aconf)
152 {
153 struct ConfItem *conf;
154
155 conf = (struct ConfItem *)((uintptr_t)aconf -
156 (uintptr_t)sizeof(struct ConfItem));
157 return(conf);
158 }
159
160 /* conf_dns_callback()
161 *
162 * inputs - pointer to struct AccessItem
163 * - pointer to DNSReply reply
164 * output - none
165 * side effects - called when resolver query finishes
166 * if the query resulted in a successful search, hp will contain
167 * a non-null pointer, otherwise hp will be null.
168 * if successful save hp in the conf item it was called with
169 */
170 static void
171 conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name)
172 {
173 struct AccessItem *aconf = vptr;
174
175 aconf->dns_pending = 0;
176
177 if (addr != NULL)
178 memcpy(&aconf->ipnum, addr, sizeof(aconf->ipnum));
179 else
180 aconf->dns_failed = 1;
181 }
182
183 /* conf_dns_lookup()
184 *
185 * do a nameserver lookup of the conf host
186 * if the conf entry is currently doing a ns lookup do nothing, otherwise
187 * allocate a dns_query and start ns lookup.
188 */
189 static void
190 conf_dns_lookup(struct AccessItem *aconf)
191 {
192 if (!aconf->dns_pending)
193 {
194 aconf->dns_pending = 1;
195 gethost_byname(conf_dns_callback, aconf, aconf->host);
196 }
197 }
198
199 /* make_conf_item()
200 *
201 * inputs - type of item
202 * output - pointer to new conf entry
203 * side effects - none
204 */
205 struct ConfItem *
206 make_conf_item(ConfType type)
207 {
208 struct ConfItem *conf = NULL;
209 struct AccessItem *aconf = NULL;
210 struct ClassItem *aclass = NULL;
211 int status = 0;
212
213 switch (type)
214 {
215 case DLINE_TYPE:
216 case EXEMPTDLINE_TYPE:
217 case GLINE_TYPE:
218 case KLINE_TYPE:
219 case CLIENT_TYPE:
220 case OPER_TYPE:
221 case SERVER_TYPE:
222 conf = MyMalloc(sizeof(struct ConfItem) +
223 sizeof(struct AccessItem));
224 aconf = map_to_conf(conf);
225 aconf->aftype = AF_INET;
226
227 /* Yes, sigh. switch on type again */
228 switch (type)
229 {
230 case EXEMPTDLINE_TYPE:
231 status = CONF_EXEMPTDLINE;
232 break;
233
234 case DLINE_TYPE:
235 status = CONF_DLINE;
236 break;
237
238 case KLINE_TYPE:
239 status = CONF_KLINE;
240 break;
241
242 case GLINE_TYPE:
243 status = CONF_GLINE;
244 break;
245
246 case CLIENT_TYPE:
247 status = CONF_CLIENT;
248 break;
249
250 case OPER_TYPE:
251 status = CONF_OPERATOR;
252 dlinkAdd(conf, &conf->node, &oconf_items);
253 break;
254
255 case SERVER_TYPE:
256 status = CONF_SERVER;
257 dlinkAdd(conf, &conf->node, &server_items);
258 break;
259
260 default:
261 break;
262 }
263 aconf->status = status;
264 break;
265
266 case LEAF_TYPE:
267 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
268 sizeof(struct MatchItem));
269 dlinkAdd(conf, &conf->node, &leaf_items);
270 break;
271
272 case HUB_TYPE:
273 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
274 sizeof(struct MatchItem));
275 dlinkAdd(conf, &conf->node, &hub_items);
276 break;
277
278 case ULINE_TYPE:
279 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
280 sizeof(struct MatchItem));
281 dlinkAdd(conf, &conf->node, &uconf_items);
282 break;
283
284 case GDENY_TYPE:
285 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
286 sizeof(struct AccessItem));
287 dlinkAdd(conf, &conf->node, &gdeny_items);
288 break;
289
290 case XLINE_TYPE:
291 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
292 sizeof(struct MatchItem));
293 dlinkAdd(conf, &conf->node, &xconf_items);
294 break;
295 #ifdef HAVE_LIBPCRE
296 case RXLINE_TYPE:
297 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
298 sizeof(struct MatchItem));
299 dlinkAdd(conf, &conf->node, &rxconf_items);
300 break;
301
302 case RKLINE_TYPE:
303 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
304 sizeof(struct AccessItem));
305 aconf = map_to_conf(conf);
306 aconf->status = CONF_KLINE;
307 dlinkAdd(conf, &conf->node, &rkconf_items);
308 break;
309 #endif
310 case CLUSTER_TYPE:
311 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem));
312 dlinkAdd(conf, &conf->node, &cluster_items);
313 break;
314
315 case CRESV_TYPE:
316 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
317 sizeof(struct ResvChannel));
318 break;
319
320 case NRESV_TYPE:
321 conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
322 sizeof(struct MatchItem));
323 dlinkAdd(conf, &conf->node, &nresv_items);
324 break;
325
326 case SERVICE_TYPE:
327 status = CONF_SERVICE;
328 conf = MyMalloc(sizeof(struct ConfItem));
329 dlinkAdd(conf, &conf->node, &service_items);
330 break;
331
332 case CLASS_TYPE:
333 conf = MyMalloc(sizeof(struct ConfItem) +
334 sizeof(struct ClassItem));
335 dlinkAdd(conf, &conf->node, &class_items);
336
337 aclass = map_to_conf(conf);
338 aclass->active = 1;
339 ConFreq(aclass) = DEFAULT_CONNECTFREQUENCY;
340 PingFreq(aclass) = DEFAULT_PINGFREQUENCY;
341 MaxTotal(aclass) = MAXIMUM_LINKS_DEFAULT;
342 MaxSendq(aclass) = DEFAULT_SENDQ;
343
344 break;
345
346 default:
347 conf = NULL;
348 break;
349 }
350
351 /* XXX Yes, this will core if default is hit. I want it to for now - db */
352 conf->type = type;
353
354 return conf;
355 }
356
357 void
358 delete_conf_item(struct ConfItem *conf)
359 {
360 dlink_node *m = NULL;
361 struct MatchItem *match_item;
362 struct AccessItem *aconf;
363 ConfType type = conf->type;
364
365 MyFree(conf->name);
366 conf->name = NULL;
367
368 switch(type)
369 {
370 case DLINE_TYPE:
371 case EXEMPTDLINE_TYPE:
372 case GLINE_TYPE:
373 case KLINE_TYPE:
374 case CLIENT_TYPE:
375 case OPER_TYPE:
376 case SERVER_TYPE:
377 aconf = map_to_conf(conf);
378
379 if (aconf->dns_pending)
380 delete_resolver_queries(aconf);
381 if (aconf->passwd != NULL)
382 memset(aconf->passwd, 0, strlen(aconf->passwd));
383 if (aconf->spasswd != NULL)
384 memset(aconf->spasswd, 0, strlen(aconf->spasswd));
385 aconf->class_ptr = NULL;
386
387 MyFree(aconf->passwd);
388 MyFree(aconf->spasswd);
389 MyFree(aconf->reason);
390 MyFree(aconf->oper_reason);
391 MyFree(aconf->user);
392 MyFree(aconf->host);
393 MyFree(aconf->cipher_list);
394 #ifdef HAVE_LIBCRYPTO
395 if (aconf->rsa_public_key)
396 RSA_free(aconf->rsa_public_key);
397 MyFree(aconf->rsa_public_key_file);
398 #endif
399
400 /* Yes, sigh. switch on type again */
401 switch(type)
402 {
403 case EXEMPTDLINE_TYPE:
404 case DLINE_TYPE:
405 case GLINE_TYPE:
406 case KLINE_TYPE:
407 case CLIENT_TYPE:
408 MyFree(conf);
409 break;
410
411 case OPER_TYPE:
412 aconf = map_to_conf(conf);
413 if (!IsConfIllegal(aconf))
414 dlinkDelete(&conf->node, &oconf_items);
415 MyFree(conf);
416 break;
417
418 case SERVER_TYPE:
419 aconf = map_to_conf(conf);
420 if (!IsConfIllegal(aconf))
421 dlinkDelete(&conf->node, &server_items);
422 MyFree(conf);
423 break;
424
425 default:
426 break;
427 }
428 break;
429
430 case HUB_TYPE:
431 match_item = map_to_conf(conf);
432 MyFree(match_item->user);
433 MyFree(match_item->host);
434 MyFree(match_item->reason);
435 MyFree(match_item->oper_reason);
436 /* If marked illegal, its already been pulled off of the hub_items list */
437 if (!match_item->illegal)
438 dlinkDelete(&conf->node, &hub_items);
439 MyFree(conf);
440 break;
441
442 case LEAF_TYPE:
443 match_item = map_to_conf(conf);
444 MyFree(match_item->user);
445 MyFree(match_item->host);
446 MyFree(match_item->reason);
447 MyFree(match_item->oper_reason);
448 /* If marked illegal, its already been pulled off of the leaf_items list */
449 if (!match_item->illegal)
450 dlinkDelete(&conf->node, &leaf_items);
451 MyFree(conf);
452 break;
453
454 case ULINE_TYPE:
455 match_item = map_to_conf(conf);
456 MyFree(match_item->user);
457 MyFree(match_item->host);
458 MyFree(match_item->reason);
459 MyFree(match_item->oper_reason);
460 dlinkDelete(&conf->node, &uconf_items);
461 MyFree(conf);
462 break;
463
464 case XLINE_TYPE:
465 match_item = map_to_conf(conf);
466 MyFree(match_item->user);
467 MyFree(match_item->host);
468 MyFree(match_item->reason);
469 MyFree(match_item->oper_reason);
470 dlinkDelete(&conf->node, &xconf_items);
471 MyFree(conf);
472 break;
473 #ifdef HAVE_LIBPCRE
474 case RKLINE_TYPE:
475 aconf = map_to_conf(conf);
476 MyFree(aconf->regexuser);
477 MyFree(aconf->regexhost);
478 MyFree(aconf->user);
479 MyFree(aconf->host);
480 MyFree(aconf->reason);
481 MyFree(aconf->oper_reason);
482 dlinkDelete(&conf->node, &rkconf_items);
483 MyFree(conf);
484 break;
485
486 case RXLINE_TYPE:
487 MyFree(conf->regexpname);
488 match_item = map_to_conf(conf);
489 MyFree(match_item->user);
490 MyFree(match_item->host);
491 MyFree(match_item->reason);
492 MyFree(match_item->oper_reason);
493 dlinkDelete(&conf->node, &rxconf_items);
494 MyFree(conf);
495 break;
496 #endif
497 case NRESV_TYPE:
498 match_item = map_to_conf(conf);
499 MyFree(match_item->user);
500 MyFree(match_item->host);
501 MyFree(match_item->reason);
502 MyFree(match_item->oper_reason);
503 dlinkDelete(&conf->node, &nresv_items);
504
505 if (conf->flags & CONF_FLAGS_TEMPORARY)
506 if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
507 free_dlink_node(m);
508
509 MyFree(conf);
510 break;
511
512 case GDENY_TYPE:
513 aconf = map_to_conf(conf);
514 MyFree(aconf->user);
515 MyFree(aconf->host);
516 dlinkDelete(&conf->node, &gdeny_items);
517 MyFree(conf);
518 break;
519
520 case CLUSTER_TYPE:
521 dlinkDelete(&conf->node, &cluster_items);
522 MyFree(conf);
523 break;
524
525 case CRESV_TYPE:
526 if (conf->flags & CONF_FLAGS_TEMPORARY)
527 if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
528 free_dlink_node(m);
529
530 MyFree(conf);
531 break;
532
533 case CLASS_TYPE:
534 dlinkDelete(&conf->node, &class_items);
535 MyFree(conf);
536 break;
537
538 case SERVICE_TYPE:
539 dlinkDelete(&conf->node, &service_items);
540 MyFree(conf);
541 break;
542
543 default:
544 break;
545 }
546 }
547
548 /* free_access_item()
549 *
550 * inputs - pointer to conf to free
551 * output - none
552 * side effects - crucial password fields are zeroed, conf is freed
553 */
554 void
555 free_access_item(struct AccessItem *aconf)
556 {
557 struct ConfItem *conf;
558
559 if (aconf == NULL)
560 return;
561 conf = unmap_conf_item(aconf);
562 delete_conf_item(conf);
563 }
564
565 static const unsigned int shared_bit_table[] =
566 { 'K', 'k', 'U', 'X', 'x', 'Y', 'Q', 'q', 'R', 'L', 0};
567
568 /* report_confitem_types()
569 *
570 * inputs - pointer to client requesting confitem report
571 * - ConfType to report
572 * output - none
573 * side effects -
574 */
575 void
576 report_confitem_types(struct Client *source_p, ConfType type, int temp)
577 {
578 dlink_node *ptr = NULL;
579 struct ConfItem *conf = NULL;
580 struct AccessItem *aconf = NULL;
581 struct MatchItem *matchitem = NULL;
582 struct ClassItem *classitem = NULL;
583 char buf[12];
584 char *p = NULL;
585 const char *pfx = NULL;
586
587 switch (type)
588 {
589 case GDENY_TYPE:
590 DLINK_FOREACH(ptr, gdeny_items.head)
591 {
592 conf = ptr->data;
593 aconf = map_to_conf(conf);
594
595 p = buf;
596
597 if (aconf->flags & GDENY_BLOCK)
598 *p++ = 'B';
599 else
600 *p++ = 'b';
601
602 if (aconf->flags & GDENY_REJECT)
603 *p++ = 'R';
604 else
605 *p++ = 'r';
606
607 *p = '\0';
608
609 sendto_one(source_p, ":%s %d %s V %s@%s %s %s",
610 me.name, RPL_STATSDEBUG, source_p->name,
611 aconf->user, aconf->host, conf->name, buf);
612 }
613 break;
614
615 case XLINE_TYPE:
616 DLINK_FOREACH(ptr, xconf_items.head)
617 {
618 conf = ptr->data;
619 matchitem = map_to_conf(conf);
620
621 sendto_one(source_p, form_str(RPL_STATSXLINE),
622 me.name, source_p->name,
623 matchitem->hold ? "x": "X", matchitem->count,
624 conf->name, matchitem->reason);
625 }
626 break;
627
628 #ifdef HAVE_LIBPCRE
629 case RXLINE_TYPE:
630 DLINK_FOREACH(ptr, rxconf_items.head)
631 {
632 conf = ptr->data;
633 matchitem = map_to_conf(conf);
634
635 sendto_one(source_p, form_str(RPL_STATSXLINE),
636 me.name, source_p->name,
637 matchitem->hold ? "xR": "XR", matchitem->count,
638 conf->name, matchitem->reason);
639 }
640 break;
641
642 case RKLINE_TYPE:
643 pfx = temp ? "kR" : "KR";
644
645 DLINK_FOREACH(ptr, rkconf_items.head)
646 {
647 aconf = map_to_conf((conf = ptr->data));
648
649 if (temp && !(conf->flags & CONF_FLAGS_TEMPORARY))
650 continue;
651
652 sendto_one(source_p, form_str(RPL_STATSKLINE), me.name,
653 source_p->name, pfx, aconf->host, aconf->user,
654 aconf->reason, aconf->oper_reason ? aconf->oper_reason : "");
655 }
656 break;
657 #endif
658
659 case ULINE_TYPE:
660 DLINK_FOREACH(ptr, uconf_items.head)
661 {
662 conf = ptr->data;
663 matchitem = map_to_conf(conf);
664
665 p = buf;
666
667 /* some of these are redundant for the sake of
668 * consistency with cluster{} flags
669 */
670 *p++ = 'c';
671 flags_to_ascii(matchitem->action, shared_bit_table, p, 0);
672
673 sendto_one(source_p, form_str(RPL_STATSULINE),
674 me.name, source_p->name, conf->name,
675 matchitem->user?matchitem->user: "*",
676 matchitem->host?matchitem->host: "*", buf);
677 }
678
679 DLINK_FOREACH(ptr, cluster_items.head)
680 {
681 conf = ptr->data;
682
683 p = buf;
684
685 *p++ = 'C';
686 flags_to_ascii(conf->flags, shared_bit_table, p, 0);
687
688 sendto_one(source_p, form_str(RPL_STATSULINE),
689 me.name, source_p->name, conf->name,
690 "*", "*", buf);
691 }
692
693 break;
694
695 case OPER_TYPE:
696 DLINK_FOREACH(ptr, oconf_items.head)
697 {
698 conf = ptr->data;
699 aconf = map_to_conf(conf);
700
701 /* Don't allow non opers to see oper privs */
702 if (HasUMode(source_p, UMODE_OPER))
703 sendto_one(source_p, form_str(RPL_STATSOLINE),
704 me.name, source_p->name, 'O', aconf->user, aconf->host,
705 conf->name, oper_privs_as_string(aconf->port),
706 aconf->class_ptr ? aconf->class_ptr->name : "<default>");
707 else
708 sendto_one(source_p, form_str(RPL_STATSOLINE),
709 me.name, source_p->name, 'O', aconf->user, aconf->host,
710 conf->name, "0",
711 aconf->class_ptr ? aconf->class_ptr->name : "<default>");
712 }
713 break;
714
715 case CLASS_TYPE:
716 DLINK_FOREACH(ptr, class_items.head)
717 {
718 conf = ptr->data;
719 classitem = map_to_conf(conf);
720 sendto_one(source_p, form_str(RPL_STATSYLINE),
721 me.name, source_p->name, 'Y',
722 conf->name, PingFreq(classitem),
723 ConFreq(classitem),
724 MaxTotal(classitem), MaxSendq(classitem),
725 CurrUserCount(classitem),
726 classitem->active ? "active" : "disabled");
727 }
728 break;
729
730 case CONF_TYPE:
731 case CLIENT_TYPE:
732 break;
733
734 case SERVICE_TYPE:
735 DLINK_FOREACH(ptr, service_items.head)
736 {
737 conf = ptr->data;
738 sendto_one(source_p, form_str(RPL_STATSSERVICE),
739 me.name, source_p->name, 'S', "*", conf->name, 0, 0);
740 }
741 break;
742
743 case SERVER_TYPE:
744 DLINK_FOREACH(ptr, server_items.head)
745 {
746 p = buf;
747
748 conf = ptr->data;
749 aconf = map_to_conf(conf);
750
751 buf[0] = '\0';
752
753 if (IsConfAllowAutoConn(aconf))
754 *p++ = 'A';
755 if (IsConfSSL(aconf))
756 *p++ = 'S';
757 if (IsConfTopicBurst(aconf))
758 *p++ = 'T';
759 if (buf[0] == '\0')
760 *p++ = '*';
761
762 *p = '\0';
763
764 /*
765 * Allow admins to see actual ips unless hide_server_ips is enabled
766 */
767 if (!ConfigServerHide.hide_server_ips && HasUMode(source_p, UMODE_ADMIN))
768 sendto_one(source_p, form_str(RPL_STATSCLINE),
769 me.name, source_p->name, 'C', aconf->host,
770 buf, conf->name, aconf->port,
771 aconf->class_ptr ? aconf->class_ptr->name : "<default>");
772 else
773 sendto_one(source_p, form_str(RPL_STATSCLINE),
774 me.name, source_p->name, 'C',
775 "*@127.0.0.1", buf, conf->name, aconf->port,
776 aconf->class_ptr ? aconf->class_ptr->name : "<default>");
777 }
778 break;
779
780 case HUB_TYPE:
781 DLINK_FOREACH(ptr, hub_items.head)
782 {
783 conf = ptr->data;
784 matchitem = map_to_conf(conf);
785 sendto_one(source_p, form_str(RPL_STATSHLINE), me.name,
786 source_p->name, 'H', matchitem->host, conf->name, 0, "*");
787 }
788 break;
789
790 case LEAF_TYPE:
791 DLINK_FOREACH(ptr, leaf_items.head)
792 {
793 conf = ptr->data;
794 matchitem = map_to_conf(conf);
795 sendto_one(source_p, form_str(RPL_STATSLLINE), me.name,
796 source_p->name, 'L', matchitem->host, conf->name, 0, "*");
797 }
798 break;
799
800 case GLINE_TYPE:
801 case KLINE_TYPE:
802 case DLINE_TYPE:
803 case EXEMPTDLINE_TYPE:
804 case CRESV_TYPE:
805 case NRESV_TYPE:
806 case CLUSTER_TYPE:
807 default:
808 break;
809 }
810 }
811
812 /* check_client()
813 *
814 * inputs - pointer to client
815 * output - 0 = Success
816 * NOT_AUTHORIZED (-1) = Access denied (no I line match)
817 * IRCD_SOCKET_ERROR (-2) = Bad socket.
818 * I_LINE_FULL (-3) = I-line is full
819 * TOO_MANY (-4) = Too many connections from hostname
820 * BANNED_CLIENT (-5) = K-lined
821 * side effects - Ordinary client access check.
822 * Look for conf lines which have the same
823 * status as the flags passed.
824 */
825 static void *
826 check_client(va_list args)
827 {
828 struct Client *source_p = va_arg(args, struct Client *);
829 const char *username = va_arg(args, const char *);
830 int i;
831
832 /* I'm already in big trouble if source_p->localClient is NULL -db */
833 if ((i = verify_access(source_p, username)))
834 ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
835 source_p->name, source_p->sockhost);
836
837 switch (i)
838 {
839 case TOO_MANY:
840 sendto_realops_flags(UMODE_FULL, L_ALL,
841 "Too many on IP for %s (%s).",
842 get_client_name(source_p, SHOW_IP),
843 source_p->sockhost);
844 ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
845 get_client_name(source_p, SHOW_IP));
846 ++ServerStats.is_ref;
847 exit_client(source_p, &me, "No more connections allowed on that IP");
848 break;
849
850 case I_LINE_FULL:
851 sendto_realops_flags(UMODE_FULL, L_ALL,
852 "I-line is full for %s (%s).",
853 get_client_name(source_p, SHOW_IP),
854 source_p->sockhost);
855 ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
856 get_client_name(source_p, SHOW_IP));
857 ++ServerStats.is_ref;
858 exit_client(source_p, &me,
859 "No more connections allowed in your connection class");
860 break;
861
862 case NOT_AUTHORIZED:
863 ++ServerStats.is_ref;
864 /* jdc - lists server name & port connections are on */
865 /* a purely cosmetical change */
866 sendto_realops_flags(UMODE_UNAUTH, L_ALL,
867 "Unauthorized client connection from %s [%s] on [%s/%u].",
868 get_client_name(source_p, SHOW_IP),
869 source_p->sockhost,
870 source_p->localClient->listener->name,
871 source_p->localClient->listener->port);
872 ilog(LOG_TYPE_IRCD,
873 "Unauthorized client connection from %s on [%s/%u].",
874 get_client_name(source_p, SHOW_IP),
875 source_p->localClient->listener->name,
876 source_p->localClient->listener->port);
877
878 /* XXX It is prolematical whether it is better to use the
879 * capture reject code here or rely on the connecting too fast code.
880 * - Dianora
881 */
882 if (REJECT_HOLD_TIME > 0)
883 {
884 sendto_one(source_p, ":%s NOTICE %s :You are not authorized to use this server",
885 me.name, source_p->name);
886 source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
887 SetCaptured(source_p);
888 }
889 else
890 exit_client(source_p, &me, "You are not authorized to use this server");
891 break;
892
893 case BANNED_CLIENT:
894 /*
895 * Don't exit them immediately, play with them a bit.
896 * - Dianora
897 */
898 if (REJECT_HOLD_TIME > 0)
899 {
900 source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
901 SetCaptured(source_p);
902 }
903 else
904 exit_client(source_p, &me, "Banned");
905 ++ServerStats.is_ref;
906 break;
907
908 case 0:
909 default:
910 break;
911 }
912
913 return (i < 0 ? NULL : source_p);
914 }
915
916 /* verify_access()
917 *
918 * inputs - pointer to client to verify
919 * - pointer to proposed username
920 * output - 0 if success -'ve if not
921 * side effect - find the first (best) I line to attach.
922 */
923 static int
924 verify_access(struct Client *client_p, const char *username)
925 {
926 struct AccessItem *aconf = NULL, *rkconf = NULL;
927 struct ConfItem *conf = NULL;
928 char non_ident[USERLEN + 1] = { '~', '\0' };
929 const char *uhi[3];
930
931 if (IsGotId(client_p))
932 {
933 aconf = find_address_conf(client_p->host, client_p->username,
934 &client_p->localClient->ip,
935 client_p->localClient->aftype,
936 client_p->localClient->passwd);
937 }
938 else
939 {
940 strlcpy(non_ident+1, username, sizeof(non_ident)-1);
941 aconf = find_address_conf(client_p->host,non_ident,
942 &client_p->localClient->ip,
943 client_p->localClient->aftype,
944 client_p->localClient->passwd);
945 }
946
947 uhi[0] = IsGotId(client_p) ? client_p->username : non_ident;
948 uhi[1] = client_p->host;
949 uhi[2] = client_p->sockhost;
950
951 rkconf = find_regexp_kline(uhi);
952
953 if (aconf != NULL)
954 {
955 if (IsConfClient(aconf) && !rkconf)
956 {
957 conf = unmap_conf_item(aconf);
958
959 if (IsConfRedir(aconf))
960 {
961 sendto_one(client_p, form_str(RPL_REDIR),
962 me.name, client_p->name,
963 conf->name ? conf->name : "",
964 aconf->port);
965 return(NOT_AUTHORIZED);
966 }
967
968 if (IsConfDoIdentd(aconf))
969 SetNeedId(client_p);
970
971 /* Thanks for spoof idea amm */
972 if (IsConfDoSpoofIp(aconf))
973 {
974 conf = unmap_conf_item(aconf);
975
976 if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(aconf))
977 sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s spoofing: %s as %s",
978 client_p->name, client_p->host, conf->name);
979 strlcpy(client_p->host, conf->name, sizeof(client_p->host));
980 SetIPSpoof(client_p);
981 }
982
983 return(attach_iline(client_p, conf));
984 }
985 else if (rkconf || IsConfKill(aconf) || (ConfigFileEntry.glines && IsConfGline(aconf)))
986 {
987 /* XXX */
988 aconf = rkconf ? rkconf : aconf;
989 if (IsConfGline(aconf))
990 sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
991 client_p->name);
992 if (ConfigFileEntry.kline_with_reason)
993 sendto_one(client_p, ":%s NOTICE %s :*** Banned %s",
994 me.name, client_p->name, aconf->reason);
995 return(BANNED_CLIENT);
996 }
997 }
998
999 return(NOT_AUTHORIZED);
1000 }
1001
1002 /* attach_iline()
1003 *
1004 * inputs - client pointer
1005 * - conf pointer
1006 * output -
1007 * side effects - do actual attach
1008 */
1009 static int
1010 attach_iline(struct Client *client_p, struct ConfItem *conf)
1011 {
1012 struct AccessItem *aconf;
1013 struct ClassItem *aclass;
1014 struct ip_entry *ip_found;
1015 int a_limit_reached = 0;
1016 int local = 0, global = 0, ident = 0;
1017
1018 ip_found = find_or_add_ip(&client_p->localClient->ip);
1019 ip_found->count++;
1020 SetIpHash(client_p);
1021
1022 aconf = map_to_conf(conf);
1023 if (aconf->class_ptr == NULL)
1024 return NOT_AUTHORIZED; /* If class is missing, this is best */
1025
1026 aclass = map_to_conf(aconf->class_ptr);
1027
1028 count_user_host(client_p->username, client_p->host,
1029 &global, &local, &ident);
1030
1031 /* XXX blah. go down checking the various silly limits
1032 * setting a_limit_reached if any limit is reached.
1033 * - Dianora
1034 */
1035 if (MaxTotal(aclass) != 0 && CurrUserCount(aclass) >= MaxTotal(aclass))
1036 a_limit_reached = 1;
1037 else if (MaxPerIp(aclass) != 0 && ip_found->count > MaxPerIp(aclass))
1038 a_limit_reached = 1;
1039 else if (MaxLocal(aclass) != 0 && local >= MaxLocal(aclass))
1040 a_limit_reached = 1;
1041 else if (MaxGlobal(aclass) != 0 && global >= MaxGlobal(aclass))
1042 a_limit_reached = 1;
1043 else if (MaxIdent(aclass) != 0 && ident >= MaxIdent(aclass) &&
1044 client_p->username[0] != '~')
1045 a_limit_reached = 1;
1046
1047 if (a_limit_reached)
1048 {
1049 if (!IsConfExemptLimits(aconf))
1050 return TOO_MANY; /* Already at maximum allowed */
1051
1052 sendto_one(client_p,
1053 ":%s NOTICE %s :*** Your connection class is full, "
1054 "but you have exceed_limit = yes;", me.name, client_p->name);
1055 }
1056
1057 return attach_conf(client_p, conf);
1058 }
1059
1060 /* init_ip_hash_table()
1061 *
1062 * inputs - NONE
1063 * output - NONE
1064 * side effects - allocate memory for ip_entry(s)
1065 * - clear the ip hash table
1066 */
1067 void
1068 init_ip_hash_table(void)
1069 {
1070 ip_entry_heap = BlockHeapCreate("ip", sizeof(struct ip_entry),
1071 2 * hard_fdlimit);
1072 memset(ip_hash_table, 0, sizeof(ip_hash_table));
1073 }
1074
1075 /* find_or_add_ip()
1076 *
1077 * inputs - pointer to struct irc_ssaddr
1078 * output - pointer to a struct ip_entry
1079 * side effects -
1080 *
1081 * If the ip # was not found, a new struct ip_entry is created, and the ip
1082 * count set to 0.
1083 */
1084 static struct ip_entry *
1085 find_or_add_ip(struct irc_ssaddr *ip_in)
1086 {
1087 struct ip_entry *ptr, *newptr;
1088 int hash_index = hash_ip(ip_in), res;
1089 struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1090 #ifdef IPV6
1091 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1092 #endif
1093
1094 for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
1095 {
1096 #ifdef IPV6
1097 if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
1098 continue;
1099 if (ip_in->ss.ss_family == AF_INET6)
1100 {
1101 ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1102 res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1103 }
1104 else
1105 #endif
1106 {
1107 ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1108 res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1109 }
1110 if (res == 0)
1111 {
1112 /* Found entry already in hash, return it. */
1113 return ptr;
1114 }
1115 }
1116
1117 if (ip_entries_count >= 2 * hard_fdlimit)
1118 garbage_collect_ip_entries();
1119
1120 newptr = BlockHeapAlloc(ip_entry_heap);
1121 ip_entries_count++;
1122 memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
1123
1124 newptr->next = ip_hash_table[hash_index];
1125 ip_hash_table[hash_index] = newptr;
1126
1127 return newptr;
1128 }
1129
1130 /* remove_one_ip()
1131 *
1132 * inputs - unsigned long IP address value
1133 * output - NONE
1134 * side effects - The ip address given, is looked up in ip hash table
1135 * and number of ip#'s for that ip decremented.
1136 * If ip # count reaches 0 and has expired,
1137 * the struct ip_entry is returned to the ip_entry_heap
1138 */
1139 void
1140 remove_one_ip(struct irc_ssaddr *ip_in)
1141 {
1142 struct ip_entry *ptr;
1143 struct ip_entry *last_ptr = NULL;
1144 int hash_index = hash_ip(ip_in), res;
1145 struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1146 #ifdef IPV6
1147 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1148 #endif
1149
1150 for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
1151 {
1152 #ifdef IPV6
1153 if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
1154 continue;
1155 if (ip_in->ss.ss_family == AF_INET6)
1156 {
1157 ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1158 res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1159 }
1160 else
1161 #endif
1162 {
1163 ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1164 res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1165 }
1166 if (res)
1167 continue;
1168 if (ptr->count > 0)
1169 ptr->count--;
1170 if (ptr->count == 0 &&
1171 (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
1172 {
1173 if (last_ptr != NULL)
1174 last_ptr->next = ptr->next;
1175 else
1176 ip_hash_table[hash_index] = ptr->next;
1177
1178 BlockHeapFree(ip_entry_heap, ptr);
1179 ip_entries_count--;
1180 return;
1181 }
1182 last_ptr = ptr;
1183 }
1184 }
1185
1186 /* hash_ip()
1187 *
1188 * input - pointer to an irc_inaddr
1189 * output - integer value used as index into hash table
1190 * side effects - hopefully, none
1191 */
1192 static int
1193 hash_ip(struct irc_ssaddr *addr)
1194 {
1195 if (addr->ss.ss_family == AF_INET)
1196 {
1197 struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
1198 int hash;
1199 uint32_t ip;
1200
1201 ip = ntohl(v4->sin_addr.s_addr);
1202 hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
1203 return hash;
1204 }
1205 #ifdef IPV6
1206 else
1207 {
1208 int hash;
1209 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
1210 uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
1211
1212 hash = ip[0] ^ ip[3];
1213 hash ^= hash >> 16;
1214 hash ^= hash >> 8;
1215 hash = hash & (IP_HASH_SIZE - 1);
1216 return hash;
1217 }
1218 #else
1219 return 0;
1220 #endif
1221 }
1222
1223 /* count_ip_hash()
1224 *
1225 * inputs - pointer to counter of number of ips hashed
1226 * - pointer to memory used for ip hash
1227 * output - returned via pointers input
1228 * side effects - NONE
1229 *
1230 * number of hashed ip #'s is counted up, plus the amount of memory
1231 * used in the hash.
1232 */
1233 void
1234 count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
1235 {
1236 struct ip_entry *ptr;
1237 int i;
1238
1239 *number_ips_stored = 0;
1240 *mem_ips_stored = 0;
1241
1242 for (i = 0; i < IP_HASH_SIZE; i++)
1243 {
1244 for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
1245 {
1246 *number_ips_stored += 1;
1247 *mem_ips_stored += sizeof(struct ip_entry);
1248 }
1249 }
1250 }
1251
1252 /* garbage_collect_ip_entries()
1253 *
1254 * input - NONE
1255 * output - NONE
1256 * side effects - free up all ip entries with no connections
1257 */
1258 static void
1259 garbage_collect_ip_entries(void)
1260 {
1261 struct ip_entry *ptr;
1262 struct ip_entry *last_ptr;
1263 struct ip_entry *next_ptr;
1264 int i;
1265
1266 for (i = 0; i < IP_HASH_SIZE; i++)
1267 {
1268 last_ptr = NULL;
1269
1270 for (ptr = ip_hash_table[i]; ptr; ptr = next_ptr)
1271 {
1272 next_ptr = ptr->next;
1273
1274 if (ptr->count == 0 &&
1275 (CurrentTime - ptr->last_attempt) >= ConfigFileEntry.throttle_time)
1276 {
1277 if (last_ptr != NULL)
1278 last_ptr->next = ptr->next;
1279 else
1280 ip_hash_table[i] = ptr->next;
1281 BlockHeapFree(ip_entry_heap, ptr);
1282 ip_entries_count--;
1283 }
1284 else
1285 last_ptr = ptr;
1286 }
1287 }
1288 }
1289
1290 /* detach_conf()
1291 *
1292 * inputs - pointer to client to detach
1293 * - type of conf to detach
1294 * output - 0 for success, -1 for failure
1295 * side effects - Disassociate configuration from the client.
1296 * Also removes a class from the list if marked for deleting.
1297 */
1298 int
1299 detach_conf(struct Client *client_p, ConfType type)
1300 {
1301 dlink_node *ptr, *next_ptr;
1302 struct ConfItem *conf;
1303 struct ClassItem *aclass;
1304 struct AccessItem *aconf;
1305 struct ConfItem *aclass_conf;
1306 struct MatchItem *match_item;
1307
1308 DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
1309 {
1310 conf = ptr->data;
1311
1312 if (type == CONF_TYPE || conf->type == type)
1313 {
1314 dlinkDelete(ptr, &client_p->localClient->confs);
1315 free_dlink_node(ptr);
1316
1317 switch (conf->type)
1318 {
1319 case CLIENT_TYPE:
1320 case OPER_TYPE:
1321 case SERVER_TYPE:
1322 aconf = map_to_conf(conf);
1323
1324 assert(aconf->clients > 0);
1325
1326 if ((aclass_conf = ClassPtr(aconf)) != NULL)
1327 {
1328 aclass = map_to_conf(aclass_conf);
1329
1330 assert(aclass->curr_user_count > 0);
1331
1332 if (conf->type == CLIENT_TYPE)
1333 remove_from_cidr_check(&client_p->localClient->ip, aclass);
1334 if (--aclass->curr_user_count == 0 && aclass->active == 0)
1335 delete_conf_item(aclass_conf);
1336 }
1337
1338 if (--aconf->clients == 0 && IsConfIllegal(aconf))
1339 delete_conf_item(conf);
1340
1341 break;
1342
1343 case LEAF_TYPE:
1344 case HUB_TYPE:
1345 match_item = map_to_conf(conf);
1346 if (match_item->ref_count == 0 && match_item->illegal)
1347 delete_conf_item(conf);
1348 break;
1349 default:
1350 break;
1351 }
1352
1353 if (type != CONF_TYPE)
1354 return 0;
1355 }
1356 }
1357
1358 return -1;
1359 }
1360
1361 /* attach_conf()
1362 *
1363 * inputs - client pointer
1364 * - conf pointer
1365 * output -
1366 * side effects - Associate a specific configuration entry to a *local*
1367 * client (this is the one which used in accepting the
1368 * connection). Note, that this automatically changes the
1369 * attachment if there was an old one...
1370 */
1371 int
1372 attach_conf(struct Client *client_p, struct ConfItem *conf)
1373 {
1374 if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
1375 return 1;
1376
1377 if (conf->type == CLIENT_TYPE ||
1378 conf->type == SERVER_TYPE ||
1379 conf->type == OPER_TYPE)
1380 {
1381 struct AccessItem *aconf = map_to_conf(conf);
1382 struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1383
1384 if (IsConfIllegal(aconf))
1385 return NOT_AUTHORIZED;
1386
1387 if (conf->type == CLIENT_TYPE)
1388 if (cidr_limit_reached(IsConfExemptLimits(aconf),
1389 &client_p->localClient->ip, aclass))
1390 return TOO_MANY; /* Already at maximum allowed */
1391
1392 CurrUserCount(aclass)++;
1393 aconf->clients++;
1394 }
1395 else if (conf->type == HUB_TYPE || conf->type == LEAF_TYPE)
1396 {
1397 struct MatchItem *match_item = map_to_conf(conf);
1398 match_item->ref_count++;
1399 }
1400
1401 dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
1402
1403 return 0;
1404 }
1405
1406 /* attach_connect_block()
1407 *
1408 * inputs - pointer to server to attach
1409 * - name of server
1410 * - hostname of server
1411 * output - true (1) if both are found, otherwise return false (0)
1412 * side effects - find connect block and attach them to connecting client
1413 */
1414 int
1415 attach_connect_block(struct Client *client_p, const char *name,
1416 const char *host)
1417 {
1418 dlink_node *ptr;
1419 struct ConfItem *conf;
1420 struct AccessItem *aconf;
1421
1422 assert(client_p != NULL);
1423 assert(host != NULL);
1424
1425 if (client_p == NULL || host == NULL)
1426 return 0;
1427
1428 DLINK_FOREACH(ptr, server_items.head)
1429 {
1430 conf = ptr->data;
1431 aconf = map_to_conf(conf);
1432
1433 if (match(conf->name, name) == 0 || match(aconf->host, host) == 0)
1434 continue;
1435
1436 attach_conf(client_p, conf);
1437 return -1;
1438 }
1439
1440 return 0;
1441 }
1442
1443 /* find_conf_exact()
1444 *
1445 * inputs - type of ConfItem
1446 * - pointer to name to find
1447 * - pointer to username to find
1448 * - pointer to host to find
1449 * output - NULL or pointer to conf found
1450 * side effects - find a conf entry which matches the hostname
1451 * and has the same name.
1452 */
1453 struct ConfItem *
1454 find_conf_exact(ConfType type, const char *name, const char *user,
1455 const char *host)
1456 {
1457 dlink_node *ptr;
1458 dlink_list *list_p;
1459 struct ConfItem *conf = NULL;
1460 struct AccessItem *aconf;
1461
1462 /* Only valid for OPER_TYPE and ...? */
1463 list_p = map_to_list(type);
1464
1465 DLINK_FOREACH(ptr, (*list_p).head)
1466 {
1467 conf = ptr->data;
1468
1469 if (conf->name == NULL)
1470 continue;
1471 aconf = map_to_conf(conf);
1472 if (aconf->host == NULL)
1473 continue;
1474 if (irccmp(conf->name, name) != 0)
1475 continue;
1476
1477 /*
1478 ** Accept if the *real* hostname (usually sockethost)
1479 ** socket host) matches *either* host or name field
1480 ** of the configuration.
1481 */
1482 if (!match(aconf->host, host) || !match(aconf->user, user))
1483 continue;
1484 if (type == OPER_TYPE)
1485 {
1486 struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1487
1488 if (aconf->clients >= MaxTotal(aclass))
1489 continue;
1490 }
1491
1492 return conf;
1493 }
1494
1495 return NULL;
1496 }
1497
1498 /* find_conf_name()
1499 *
1500 * inputs - pointer to conf link list to search
1501 * - pointer to name to find
1502 * - int mask of type of conf to find
1503 * output - NULL or pointer to conf found
1504 * side effects - find a conf entry which matches the name
1505 * and has the given mask.
1506 */
1507 struct ConfItem *
1508 find_conf_name(dlink_list *list, const char *name, ConfType type)
1509 {
1510 dlink_node *ptr;
1511 struct ConfItem* conf;
1512
1513 DLINK_FOREACH(ptr, list->head)
1514 {
1515 conf = ptr->data;
1516
1517 if (conf->type == type)
1518 {
1519 if (conf->name && (irccmp(conf->name, name) == 0 ||
1520 match(conf->name, name)))
1521 return conf;
1522 }
1523 }
1524
1525 return NULL;
1526 }
1527
1528 /* map_to_list()
1529 *
1530 * inputs - ConfType conf
1531 * output - pointer to dlink_list to use
1532 * side effects - none
1533 */
1534 static dlink_list *
1535 map_to_list(ConfType type)
1536 {
1537 switch(type)
1538 {
1539 case RXLINE_TYPE:
1540 return(&rxconf_items);
1541 break;
1542 case XLINE_TYPE:
1543 return(&xconf_items);
1544 break;
1545 case ULINE_TYPE:
1546 return(&uconf_items);
1547 break;
1548 case NRESV_TYPE:
1549 return(&nresv_items);
1550 break;
1551 case OPER_TYPE:
1552 return(&oconf_items);
1553 break;
1554 case CLASS_TYPE:
1555 return(&class_items);
1556 break;
1557 case SERVER_TYPE:
1558 return(&server_items);
1559 break;
1560 case SERVICE_TYPE:
1561 return(&service_items);
1562 break;
1563 case CLUSTER_TYPE:
1564 return(&cluster_items);
1565 break;
1566 case CONF_TYPE:
1567 case GLINE_TYPE:
1568 case KLINE_TYPE:
1569 case DLINE_TYPE:
1570 case CRESV_TYPE:
1571 default:
1572 return NULL;
1573 }
1574 }
1575
1576 /* find_matching_name_conf()
1577 *
1578 * inputs - type of link list to look in
1579 * - pointer to name string to find
1580 * - pointer to user
1581 * - pointer to host
1582 * - optional action to match on as well
1583 * output - NULL or pointer to found struct MatchItem
1584 * side effects - looks for a match on name field
1585 */
1586 struct ConfItem *
1587 find_matching_name_conf(ConfType type, const char *name, const char *user,
1588 const char *host, int action)
1589 {
1590 dlink_node *ptr=NULL;
1591 struct ConfItem *conf=NULL;
1592 struct AccessItem *aconf=NULL;
1593 struct MatchItem *match_item=NULL;
1594 dlink_list *list_p = map_to_list(type);
1595
1596 switch (type)
1597 {
1598 #ifdef HAVE_LIBPCRE
1599 case RXLINE_TYPE:
1600 DLINK_FOREACH(ptr, list_p->head)
1601 {
1602 conf = ptr->data;
1603 assert(conf->regexpname);
1604
1605 if (!ircd_pcre_exec(conf->regexpname, name))
1606 return conf;
1607 }
1608 break;
1609 #endif
1610 case SERVICE_TYPE:
1611 DLINK_FOREACH(ptr, list_p->head)
1612 {
1613 conf = ptr->data;
1614
1615 if (EmptyString(conf->name))
1616 continue;
1617 if ((name != NULL) && !irccmp(name, conf->name))
1618 return conf;
1619 }
1620 break;
1621
1622 case XLINE_TYPE:
1623 case ULINE_TYPE:
1624 case NRESV_TYPE:
1625 DLINK_FOREACH(ptr, list_p->head)
1626 {
1627 conf = ptr->data;
1628
1629 match_item = map_to_conf(conf);
1630 if (EmptyString(conf->name))
1631 continue;
1632 if ((name != NULL) && match_esc(conf->name, name))
1633 {
1634 if ((user == NULL && (host == NULL)))
1635 return conf;
1636 if ((match_item->action & action) != action)
1637 continue;
1638 if (EmptyString(match_item->user) || EmptyString(match_item->host))
1639 return conf;
1640 if (match(match_item->user, user) && match(match_item->host, host))
1641 return conf;
1642 }
1643 }
1644 break;
1645
1646 case SERVER_TYPE:
1647 DLINK_FOREACH(ptr, list_p->head)
1648 {
1649 conf = ptr->data;
1650 aconf = map_to_conf(conf);
1651
1652 if ((name != NULL) && match_esc(name, conf->name))
1653 return conf;
1654 else if ((host != NULL) && match_esc(host, aconf->host))
1655 return conf;
1656 }
1657 break;
1658
1659 default:
1660 break;
1661 }
1662 return NULL;
1663 }
1664
1665 /* find_exact_name_conf()
1666 *
1667 * inputs - type of link list to look in
1668 * - pointer to name string to find
1669 * - pointer to user
1670 * - pointer to host
1671 * output - NULL or pointer to found struct MatchItem
1672 * side effects - looks for an exact match on name field
1673 */
1674 struct ConfItem *
1675 find_exact_name_conf(ConfType type, const struct Client *who, const char *name,
1676 const char *user, const char *host)
1677 {
1678 dlink_node *ptr = NULL;
1679 struct AccessItem *aconf;
1680 struct ConfItem *conf;
1681 struct MatchItem *match_item;
1682 dlink_list *list_p;
1683
1684 list_p = map_to_list(type);
1685
1686 switch(type)
1687 {
1688 case RXLINE_TYPE:
1689 case XLINE_TYPE:
1690 case ULINE_TYPE:
1691 case NRESV_TYPE:
1692
1693 DLINK_FOREACH(ptr, list_p->head)
1694 {
1695 conf = ptr->data;
1696 match_item = (struct MatchItem *)map_to_conf(conf);
1697 if (EmptyString(conf->name))
1698 continue;
1699
1700 if (irccmp(conf->name, name) == 0)
1701 {
1702 if ((user == NULL && (host == NULL)))
1703 return (conf);
1704 if (EmptyString(match_item->user) || EmptyString(match_item->host))
1705 return (conf);
1706 if (match(match_item->user, user) && match(match_item->host, host))
1707 return (conf);
1708 }
1709 }
1710 break;
1711
1712 case OPER_TYPE:
1713 DLINK_FOREACH(ptr, list_p->head)
1714 {
1715 conf = ptr->data;
1716 aconf = map_to_conf(conf);
1717
1718 if (EmptyString(conf->name))
1719 continue;
1720
1721 if (!irccmp(conf->name, name))
1722 {
1723 if (!who)
1724 return conf;
1725 if (EmptyString(aconf->user) || EmptyString(aconf->host))
1726 return conf;
1727 if (match(aconf->user, who->username))
1728 {
1729 switch (aconf->type)
1730 {
1731 case HM_HOST:
1732 if (match(aconf->host, who->host) || match(aconf->host, who->sockhost))
1733 return conf;
1734 break;
1735 case HM_IPV4:
1736 if (who->localClient->aftype == AF_INET)
1737 if (match_ipv4(&who->localClient->ip, &aconf->ipnum, aconf->bits))
1738 return conf;
1739 break;
1740 #ifdef IPV6
1741 case HM_IPV6:
1742 if (who->localClient->aftype == AF_INET6)
1743 if (match_ipv6(&who->localClient->ip, &aconf->ipnum, aconf->bits))
1744 return conf;
1745 break;
1746 #endif
1747 default:
1748 assert(0);
1749 }
1750 }
1751 }
1752 }
1753
1754 break;
1755
1756 case SERVER_TYPE:
1757 DLINK_FOREACH(ptr, list_p->head)
1758 {
1759 conf = ptr->data;
1760 aconf = (struct AccessItem *)map_to_conf(conf);
1761 if (EmptyString(conf->name))
1762 continue;
1763
1764 if (name == NULL)
1765 {
1766 if (EmptyString(aconf->host))
1767 continue;
1768 if (irccmp(aconf->host, host) == 0)
1769 return(conf);
1770 }
1771 else if (irccmp(conf->name, name) == 0)
1772 {
1773 return (conf);
1774 }
1775 }
1776 break;
1777
1778 case CLASS_TYPE:
1779 DLINK_FOREACH(ptr, list_p->head)
1780 {
1781 conf = ptr->data;
1782 if (EmptyString(conf->name))
1783 continue;
1784
1785 if (irccmp(conf->name, name) == 0)
1786 return (conf);
1787 }
1788 break;
1789
1790 default:
1791 break;
1792 }
1793 return(NULL);
1794 }
1795
1796 /* rehash()
1797 *
1798 * Actual REHASH service routine. Called with sig == 0 if it has been called
1799 * as a result of an operator issuing this command, else assume it has been
1800 * called as a result of the server receiving a HUP signal.
1801 */
1802 int
1803 rehash(int sig)
1804 {
1805 if (sig != 0)
1806 sendto_realops_flags(UMODE_ALL, L_ALL,
1807 "Got signal SIGHUP, reloading ircd.conf file");
1808
1809 restart_resolver();
1810
1811 /* don't close listeners until we know we can go ahead with the rehash */
1812
1813 /* Check to see if we magically got(or lost) IPv6 support */
1814 check_can_use_v6();
1815
1816 read_conf_files(0);
1817
1818 if (ServerInfo.description != NULL)
1819 strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1820
1821 load_conf_modules();
1822
1823 flush_deleted_I_P();
1824
1825 rehashed_klines = 1;
1826 /* XXX */
1827 if (ConfigLoggingEntry.use_logging)
1828 log_close_all();
1829
1830 return(0);
1831 }
1832
1833 /* set_default_conf()
1834 *
1835 * inputs - NONE
1836 * output - NONE
1837 * side effects - Set default values here.
1838 * This is called **PRIOR** to parsing the
1839 * configuration file. If you want to do some validation
1840 * of values later, put them in validate_conf().
1841 */
1842 static void
1843 set_default_conf(void)
1844 {
1845 /* verify init_class() ran, this should be an unnecessary check
1846 * but its not much work.
1847 */
1848 assert(class_default == (struct ConfItem *) class_items.tail->data);
1849
1850 #ifdef HAVE_LIBCRYPTO
1851 ServerInfo.rsa_private_key = NULL;
1852 ServerInfo.rsa_private_key_file = NULL;
1853 #endif
1854
1855 /* ServerInfo.name is not rehashable */
1856 /* ServerInfo.name = ServerInfo.name; */
1857 ServerInfo.description = NULL;
1858 DupString(ServerInfo.network_name, NETWORK_NAME_DEFAULT);
1859 DupString(ServerInfo.network_desc, NETWORK_DESC_DEFAULT);
1860
1861 memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
1862 ServerInfo.specific_ipv4_vhost = 0;
1863 memset(&ServerInfo.ip6, 0, sizeof(ServerInfo.ip6));
1864 ServerInfo.specific_ipv6_vhost = 0;
1865
1866 ServerInfo.max_clients = MAXCLIENTS_MAX;
1867
1868 ServerInfo.hub = 0;
1869 ServerInfo.dns_host.sin_addr.s_addr = 0;
1870 ServerInfo.dns_host.sin_port = 0;
1871 AdminInfo.name = NULL;
1872 AdminInfo.email = NULL;
1873 AdminInfo.description = NULL;
1874
1875 log_close_all();
1876
1877 ConfigLoggingEntry.use_logging = 1;
1878
1879 ConfigChannel.disable_fake_channels = 0;
1880 ConfigChannel.restrict_channels = 0;
1881 ConfigChannel.disable_local_channels = 0;
1882 ConfigChannel.use_invex = 1;
1883 ConfigChannel.use_except = 1;
1884 ConfigChannel.use_knock = 1;
1885 ConfigChannel.knock_delay = 300;
1886 ConfigChannel.knock_delay_channel = 60;
1887 ConfigChannel.max_chans_per_user = 15;
1888 ConfigChannel.quiet_on_ban = 1;
1889 ConfigChannel.max_bans = 25;
1890 ConfigChannel.default_split_user_count = 0;
1891 ConfigChannel.default_split_server_count = 0;
1892 ConfigChannel.no_join_on_split = 0;
1893 ConfigChannel.no_create_on_split = 0;
1894 ConfigChannel.burst_topicwho = 1;
1895
1896 ConfigServerHide.flatten_links = 0;
1897 ConfigServerHide.links_delay = 300;
1898 ConfigServerHide.hidden = 0;
1899 ConfigServerHide.disable_hidden = 0;
1900 ConfigServerHide.hide_servers = 0;
1901 DupString(ConfigServerHide.hidden_name, NETWORK_NAME_DEFAULT);
1902 ConfigServerHide.hide_server_ips = 0;
1903
1904
1905 DupString(ConfigFileEntry.service_name, SERVICE_NAME_DEFAULT);
1906 ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
1907 ConfigFileEntry.gline_min_cidr = 16;
1908 ConfigFileEntry.gline_min_cidr6 = 48;
1909 ConfigFileEntry.invisible_on_connect = 1;
1910 ConfigFileEntry.burst_away = 0;
1911 ConfigFileEntry.use_whois_actually = 1;
1912 ConfigFileEntry.tkline_expire_notices = 1;
1913 ConfigFileEntry.hide_spoof_ips = 1;
1914 ConfigFileEntry.ignore_bogus_ts = 0;
1915 ConfigFileEntry.disable_auth = 0;
1916 ConfigFileEntry.disable_remote = 0;
1917 ConfigFileEntry.kill_chase_time_limit = 90;
1918 ConfigFileEntry.default_floodcount = 8;
1919 ConfigFileEntry.failed_oper_notice = 1;
1920 ConfigFileEntry.dots_in_ident = 0;
1921 ConfigFileEntry.min_nonwildcard = 4;
1922 ConfigFileEntry.min_nonwildcard_simple = 3;
1923 ConfigFileEntry.max_accept = 20;
1924 ConfigFileEntry.anti_nick_flood = 0;
1925 ConfigFileEntry.max_nick_time = 20;
1926 ConfigFileEntry.max_nick_changes = 5;
1927 ConfigFileEntry.anti_spam_exit_message_time = 0;
1928 ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1929 ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1930 ConfigFileEntry.kline_with_reason = 1;
1931 ConfigFileEntry.kline_reason = NULL;
1932 ConfigFileEntry.warn_no_nline = 1;
1933 ConfigFileEntry.stats_o_oper_only = 0;
1934 ConfigFileEntry.stats_k_oper_only = 1; /* masked */
1935 ConfigFileEntry.stats_i_oper_only = 1; /* masked */
1936 ConfigFileEntry.stats_P_oper_only = 0;
1937 ConfigFileEntry.caller_id_wait = 60;
1938 ConfigFileEntry.opers_bypass_callerid = 0;
1939 ConfigFileEntry.pace_wait = 10;
1940 ConfigFileEntry.pace_wait_simple = 1;
1941 ConfigFileEntry.short_motd = 0;
1942 ConfigFileEntry.ping_cookie = 0;
1943 ConfigFileEntry.no_oper_flood = 0;
1944 ConfigFileEntry.true_no_oper_flood = 0;
1945 ConfigFileEntry.oper_pass_resv = 1;
1946 ConfigFileEntry.glines = 0;
1947 ConfigFileEntry.gline_time = 12 * 3600;
1948 ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
1949 ConfigFileEntry.client_flood = CLIENT_FLOOD_DEFAULT;
1950 ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
1951 ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
1952 UMODE_OPERWALL | UMODE_WALLOP;
1953 ConfigFileEntry.use_egd = 0;
1954 ConfigFileEntry.egdpool_path = NULL;
1955 ConfigFileEntry.throttle_time = 10;
1956 }
1957
1958 /* read_conf()
1959 *
1960 * inputs - file descriptor pointing to config file to use
1961 * output - None
1962 * side effects - Read configuration file.
1963 */
1964 static void
1965 read_conf(FBFILE *file)
1966 {
1967 lineno = 0;
1968
1969 set_default_conf(); /* Set default values prior to conf parsing */
1970 conf_parser_ctx.pass = 1;
1971 yyparse(); /* pick up the classes first */
1972
1973 fbrewind(file);
1974
1975 conf_parser_ctx.pass = 2;
1976 yyparse(); /* Load the values from the conf */
1977 validate_conf(); /* Check to make sure some values are still okay. */
1978 /* Some global values are also loaded here. */
1979 check_class(); /* Make sure classes are valid */
1980 }
1981
1982 static void
1983 validate_conf(void)
1984 {
1985 if (ConfigFileEntry.ts_warn_delta < TS_WARN_DELTA_MIN)
1986 ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1987
1988 if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
1989 ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1990
1991 if (ServerInfo.network_name == NULL)
1992 DupString(ServerInfo.network_name,NETWORK_NAME_DEFAULT);
1993
1994 if (ServerInfo.network_desc == NULL)
1995 DupString(ServerInfo.network_desc,NETWORK_DESC_DEFAULT);
1996
1997 if (ConfigFileEntry.service_name == NULL)
1998 DupString(ConfigFileEntry.service_name, SERVICE_NAME_DEFAULT);
1999
2000 if ((ConfigFileEntry.client_flood < CLIENT_FLOOD_MIN) ||
2001 (ConfigFileEntry.client_flood > CLIENT_FLOOD_MAX))
2002 ConfigFileEntry.client_flood = CLIENT_FLOOD_MAX;
2003
2004 ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
2005 }
2006
2007 /* lookup_confhost()
2008 *
2009 * start DNS lookups of all hostnames in the conf
2010 * line and convert an IP addresses in a.b.c.d number for to IP#s.
2011 */
2012 static void
2013 lookup_confhost(struct ConfItem *conf)
2014 {
2015 struct AccessItem *aconf;
2016 struct addrinfo hints, *res;
2017
2018 aconf = map_to_conf(conf);
2019
2020 if (EmptyString(aconf->host) ||
2021 EmptyString(aconf->user))
2022 {
2023 ilog(LOG_TYPE_IRCD, "Host/server name error: (%s) (%s)",
2024 aconf->host, conf->name);
2025 return;
2026 }
2027
2028 if (strchr(aconf->host, '*') ||
2029 strchr(aconf->host, '?'))
2030 return;
2031
2032 /* Do name lookup now on hostnames given and store the
2033 * ip numbers in conf structure.
2034 */
2035 memset(&hints, 0, sizeof(hints));
2036
2037 hints.ai_family = AF_UNSPEC;
2038 hints.ai_socktype = SOCK_STREAM;
2039
2040 /* Get us ready for a bind() and don't bother doing dns lookup */
2041 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
2042
2043 if (getaddrinfo(aconf->host, NULL, &hints, &res))
2044 {
2045 conf_dns_lookup(aconf);
2046 return;
2047 }
2048
2049 assert(res != NULL);
2050
2051 memcpy(&aconf->ipnum, res->ai_addr, res->ai_addrlen);
2052 aconf->ipnum.ss_len = res->ai_addrlen;
2053 aconf->ipnum.ss.ss_family = res->ai_family;
2054 freeaddrinfo(res);
2055 }
2056
2057 /* conf_connect_allowed()
2058 *
2059 * inputs - pointer to inaddr
2060 * - int type ipv4 or ipv6
2061 * output - BANNED or accepted
2062 * side effects - none
2063 */
2064 int
2065 conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
2066 {
2067 struct ip_entry *ip_found;
2068 struct AccessItem *aconf = find_dline_conf(addr, aftype);
2069
2070 /* DLINE exempt also gets you out of static limits/pacing... */
2071 if (aconf && (aconf->status & CONF_EXEMPTDLINE))
2072 return 0;
2073
2074 if (aconf != NULL)
2075 return BANNED_CLIENT;
2076
2077 ip_found = find_or_add_ip(addr);
2078
2079 if ((CurrentTime - ip_found->last_attempt) <
2080 ConfigFileEntry.throttle_time)
2081 {
2082 ip_found->last_attempt = CurrentTime;
2083 return TOO_FAST;
2084 }
2085
2086 ip_found->last_attempt = CurrentTime;
2087 return 0;
2088 }
2089
2090 static struct AccessItem *
2091 find_regexp_kline(const char *uhi[])
2092 {
2093 #ifdef HAVE_LIBPCRE
2094 const dlink_node *ptr = NULL;
2095
2096 DLINK_FOREACH(ptr, rkconf_items.head)
2097 {
2098 struct AccessItem *aptr = map_to_conf(ptr->data);
2099
2100 assert(aptr->regexuser);
2101 assert(aptr->regexhost);
2102
2103 if (!ircd_pcre_exec(aptr->regexuser, uhi[0]) &&
2104 (!ircd_pcre_exec(aptr->regexhost, uhi[1]) ||
2105 !ircd_pcre_exec(aptr->regexhost, uhi[2])))
2106 return aptr;
2107 }
2108 #endif
2109 return NULL;
2110 }
2111
2112 /* find_kill()
2113 *
2114 * inputs - pointer to client structure
2115 * output - pointer to struct AccessItem if found
2116 * side effects - See if this user is klined already,
2117 * and if so, return struct AccessItem pointer
2118 */
2119 struct AccessItem *
2120 find_kill(struct Client *client_p)
2121 {
2122 struct AccessItem *aconf = NULL;
2123 const char *uhi[3];
2124
2125 uhi[0] = client_p->username;
2126 uhi[1] = client_p->host;
2127 uhi[2] = client_p->sockhost;
2128
2129 assert(client_p != NULL);
2130
2131 aconf = find_kline_conf(client_p->host, client_p->username,
2132 &client_p->localClient->ip,
2133 client_p->localClient->aftype);
2134 if (aconf == NULL)
2135 aconf = find_regexp_kline(uhi);
2136
2137 if (aconf && (aconf->status & CONF_KLINE))
2138 return aconf;
2139
2140 return NULL;
2141 }
2142
2143 struct AccessItem *
2144 find_gline(struct Client *client_p)
2145 {
2146 struct AccessItem *aconf;
2147
2148 assert(client_p != NULL);
2149
2150 aconf = find_gline_conf(client_p->host, client_p->username,
2151 &client_p->localClient->ip,
2152 client_p->localClient->aftype);
2153
2154 if (aconf && (aconf->status & CONF_GLINE))
2155 return aconf;
2156
2157 return NULL;
2158 }
2159
2160 /* add_temp_line()
2161 *
2162 * inputs - pointer to struct ConfItem
2163 * output - none
2164 * Side effects - links in given struct ConfItem into
2165 * temporary *line link list
2166 */
2167 void
2168 add_temp_line(struct ConfItem *conf)
2169 {
2170 struct AccessItem *aconf;
2171
2172 if (conf->type == DLINE_TYPE)
2173 {
2174 aconf = map_to_conf(conf);
2175 SetConfTemporary(aconf);
2176 dlinkAdd(conf, &conf->node, &temporary_dlines);
2177 MyFree(aconf->user);
2178 aconf->user = NULL;
2179 add_conf_by_address(CONF_DLINE, aconf);
2180 }
2181 else if (conf->type == KLINE_TYPE)
2182 {
2183 aconf = map_to_conf(conf);
2184 SetConfTemporary(aconf);
2185 dlinkAdd(conf, &conf->node, &temporary_klines);
2186 add_conf_by_address(CONF_KILL, aconf);
2187 }
2188 else if (conf->type == GLINE_TYPE)
2189 {
2190 aconf = map_to_conf(conf);
2191 SetConfTemporary(aconf);
2192 dlinkAdd(conf, &conf->node, &temporary_glines);
2193 add_conf_by_address(CONF_GLINE, aconf);
2194 }
2195 else if (conf->type == XLINE_TYPE)
2196 {
2197 conf->flags |= CONF_FLAGS_TEMPORARY;
2198 dlinkAdd(conf, make_dlink_node(), &temporary_xlines);
2199 }
2200 else if (conf->type == RXLINE_TYPE)
2201 {
2202 conf->flags |= CONF_FLAGS_TEMPORARY;
2203 dlinkAdd(conf, make_dlink_node(), &temporary_rxlines);
2204 }
2205 else if (conf->type == RKLINE_TYPE)
2206 {
2207 conf->flags |= CONF_FLAGS_TEMPORARY;
2208 dlinkAdd(conf, make_dlink_node(), &temporary_rklines);
2209 }
2210 else if ((conf->type == NRESV_TYPE) || (conf->type == CRESV_TYPE))
2211 {
2212 conf->flags |= CONF_FLAGS_TEMPORARY;
2213 dlinkAdd(conf, make_dlink_node(), &temporary_resv);
2214 }
2215 }
2216
2217 /* cleanup_tklines()
2218 *
2219 * inputs - NONE
2220 * output - NONE
2221 * side effects - call function to expire temporary k/d lines
2222 * This is an event started off in ircd.c
2223 */
2224 void
2225 cleanup_tklines(void *notused)
2226 {
2227 expire_tklines(&temporary_glines);
2228 expire_tklines(&temporary_klines);
2229 expire_tklines(&temporary_dlines);
2230 expire_tklines(&temporary_xlines);
2231 expire_tklines(&temporary_rxlines);
2232 expire_tklines(&temporary_rklines);
2233 expire_tklines(&temporary_resv);
2234 }
2235
2236 /* expire_tklines()
2237 *
2238 * inputs - tkline list pointer
2239 * output - NONE
2240 * side effects - expire tklines
2241 */
2242 static void
2243 expire_tklines(dlink_list *tklist)
2244 {
2245 dlink_node *ptr;
2246 dlink_node *next_ptr;
2247 struct ConfItem *conf;
2248 struct MatchItem *xconf;
2249 struct MatchItem *nconf;
2250 struct AccessItem *aconf;
2251 struct ResvChannel *cconf;
2252
2253 DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
2254 {
2255 conf = ptr->data;
2256 if (conf->type == GLINE_TYPE ||
2257 conf->type == KLINE_TYPE ||
2258 conf->type == DLINE_TYPE)
2259 {
2260 aconf = (struct AccessItem *)map_to_conf(conf);
2261 if (aconf->hold <= CurrentTime)
2262 {
2263 /* XXX - Do we want GLINE expiry notices?? */
2264 /* Alert opers that a TKline expired - Hwy */
2265 if (ConfigFileEntry.tkline_expire_notices)
2266 {
2267 if (aconf->status & CONF_KILL)
2268 {
2269 sendto_realops_flags(UMODE_ALL, L_ALL,
2270 "Temporary K-line for [%s@%s] expired",
2271 (aconf->user) ? aconf->user : "*",
2272 (aconf->host) ? aconf->host : "*");
2273 }
2274 else if (conf->type == DLINE_TYPE)
2275 {
2276 sendto_realops_flags(UMODE_ALL, L_ALL,
2277 "Temporary D-line for [%s] expired",
2278 (aconf->host) ? aconf->host : "*");
2279 }
2280 }
2281
2282 dlinkDelete(ptr, tklist);
2283 delete_one_address_conf(aconf->host, aconf);
2284 }
2285 }
2286 else if (conf->type == XLINE_TYPE ||
2287 conf->type == RXLINE_TYPE)
2288 {
2289 xconf = (struct MatchItem *)map_to_conf(conf);
2290 if (xconf->hold <= CurrentTime)
2291 {
2292 if (ConfigFileEntry.tkline_expire_notices)
2293 sendto_realops_flags(UMODE_ALL, L_ALL,
2294 "Temporary X-line for [%s] %sexpired", conf->name,
2295 conf->type == RXLINE_TYPE ? "(REGEX) " : "");
2296 dlinkDelete(ptr, tklist);
2297 free_dlink_node(ptr);
2298 delete_conf_item(conf);
2299 }
2300 }
2301 else if (conf->type == RKLINE_TYPE)
2302 {
2303 aconf = map_to_conf(conf);
2304 if (aconf->hold <= CurrentTime)
2305 {
2306 if (ConfigFileEntry.tkline_expire_notices)
2307 sendto_realops_flags(UMODE_ALL, L_ALL,
2308 "Temporary K-line for [%s@%s] (REGEX) expired",
2309 (aconf->user) ? aconf->user : "*",
2310 (aconf->host) ? aconf->host : "*");
2311 dlinkDelete(ptr, tklist);
2312 free_dlink_node(ptr);
2313 delete_conf_item(conf);
2314 }
2315 }
2316 else if (conf->type == NRESV_TYPE)
2317 {
2318 nconf = (struct MatchItem *)map_to_conf(conf);
2319 if (nconf->hold <= CurrentTime)
2320 {
2321 if (ConfigFileEntry.tkline_expire_notices)
2322 sendto_realops_flags(UMODE_ALL, L_ALL,
2323 "Temporary RESV for [%s] expired", conf->name);
2324 dlinkDelete(ptr, tklist);
2325 free_dlink_node(ptr);
2326 delete_conf_item(conf);
2327 }
2328 }
2329 else if (conf->type == CRESV_TYPE)
2330 {
2331 cconf = (struct ResvChannel *)map_to_conf(conf);
2332 if (cconf->hold <= CurrentTime)
2333 {
2334 if (ConfigFileEntry.tkline_expire_notices)
2335 sendto_realops_flags(UMODE_ALL, L_ALL,
2336 "Temporary RESV for [%s] expired", cconf->name);
2337 delete_channel_resv(cconf);
2338 }
2339 }
2340 }
2341 }
2342
2343 /* oper_privs_as_string()
2344 *
2345 * inputs - pointer to client_p
2346 * output - pointer to static string showing oper privs
2347 * side effects - return as string, the oper privs as derived from port
2348 */
2349 static const struct oper_privs
2350 {
2351 const unsigned int oprivs;
2352 const unsigned char c;
2353 } flag_list[] = {
2354 { OPER_FLAG_ADMIN, 'A' },
2355 { OPER_FLAG_REMOTEBAN, 'B' },
2356 { OPER_FLAG_DIE, 'D' },
2357 { OPER_FLAG_GLINE, 'G' },
2358 { OPER_FLAG_REHASH, 'H' },
2359 { OPER_FLAG_K, 'K' },
2360 { OPER_FLAG_OPERWALL, 'L' },
2361 { OPER_FLAG_N, 'N' },
2362 { OPER_FLAG_GLOBAL_KILL, 'O' },
2363 { OPER_FLAG_REMOTE, 'R' },
2364 { OPER_FLAG_OPER_SPY, 'S' },
2365 { OPER_FLAG_UNKLINE, 'U' },
2366 { OPER_FLAG_X, 'X' },
2367 { 0, '\0' }
2368 };
2369
2370 char *
2371 oper_privs_as_string(const unsigned int port)
2372 {
2373 static char privs_out[16];
2374 char *privs_ptr = privs_out;
2375 unsigned int i = 0;
2376
2377 for (; flag_list[i].oprivs; ++i)
2378 {
2379 if (port & flag_list[i].oprivs)
2380 *privs_ptr++ = flag_list[i].c;
2381 else
2382 *privs_ptr++ = ToLowerTab[flag_list[i].c];
2383 }
2384
2385 *privs_ptr = '\0';
2386
2387 return privs_out;
2388 }
2389
2390 /*
2391 * Input: A client to find the active oper{} name for.
2392 * Output: The nick!user@host{oper} of the oper.
2393 * "oper" is server name for remote opers
2394 * Side effects: None.
2395 */
2396 char *
2397 get_oper_name(const struct Client *client_p)
2398 {
2399 dlink_node *cnode;
2400 struct ConfItem *conf;
2401 struct AccessItem *aconf;
2402
2403 /* +5 for !,@,{,} and null */
2404 static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
2405
2406 if (MyConnect(client_p))
2407 {
2408 DLINK_FOREACH(cnode, client_p->localClient->confs.head)
2409 {
2410 conf = cnode->data;
2411 aconf = map_to_conf(conf);
2412
2413 if (IsConfOperator(aconf))
2414 {
2415 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
2416 client_p->username, client_p->host, conf->name);
2417 return buffer;
2418 }
2419 }
2420
2421 /* Probably should assert here for now. If there is an oper out there
2422 * with no oper{} conf attached, it would be good for us to know...
2423 */
2424 assert(0); /* Oper without oper conf! */
2425 }
2426
2427 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
2428 client_p->username, client_p->host, client_p->servptr->name);
2429 return buffer;
2430 }
2431
2432 /* read_conf_files()
2433 *
2434 * inputs - cold start YES or NO
2435 * output - none
2436 * side effects - read all conf files needed, ircd.conf kline.conf etc.
2437 */
2438 void
2439 read_conf_files(int cold)
2440 {
2441 const char *filename;
2442 char chanmodes[32];
2443 char chanlimit[32];
2444
2445 conf_parser_ctx.boot = cold;
2446 filename = get_conf_name(CONF_TYPE);
2447
2448 /* We need to know the initial filename for the yyerror() to report
2449 FIXME: The full path is in conffilenamebuf first time since we
2450 dont know anything else
2451
2452 - Gozem 2002-07-21
2453 */
2454 strlcpy(conffilebuf, filename, sizeof(conffilebuf));
2455
2456 if ((conf_parser_ctx.conf_file = fbopen(filename, "r")) == NULL)
2457 {
2458 if (cold)
2459 {
2460 ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
2461 filename, strerror(errno));
2462 exit(-1);
2463 }
2464 else
2465 {
2466 sendto_realops_flags(UMODE_ALL, L_ALL,
2467 "Unable to read configuration file '%s': %s",
2468 filename, strerror(errno));
2469 return;
2470 }
2471 }
2472
2473 if (!cold)
2474 clear_out_old_conf();
2475
2476 read_conf(conf_parser_ctx.conf_file);
2477 fbclose(conf_parser_ctx.conf_file);
2478
2479 add_isupport("NETWORK", ServerInfo.network_name, -1);
2480 snprintf(chanmodes, sizeof(chanmodes), "b%s%s:%d",
2481 ConfigChannel.use_except ? "e" : "",
2482 ConfigChannel.use_invex ? "I" : "", ConfigChannel.max_bans);
2483 add_isupport("MAXLIST", chanmodes, -1);
2484 add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
2485
2486 if (ConfigChannel.disable_local_channels)
2487 add_isupport("CHANTYPES", "#", -1);
2488 else
2489 add_isupport("CHANTYPES", "#&", -1);
2490
2491 snprintf(chanlimit, sizeof(chanlimit), "%s:%d",
2492 ConfigChannel.disable_local_channels ? "#" : "#&",
2493 ConfigChannel.max_chans_per_user);
2494 add_isupport("CHANLIMIT", chanlimit, -1);
2495 snprintf(chanmodes, sizeof(chanmodes), "%s%s%s",
2496 ConfigChannel.use_except ? "e" : "",
2497 ConfigChannel.use_invex ? "I" : "", "b,k,l,imnprstORS");
2498 add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
2499
2500 if (ConfigChannel.use_except)
2501 add_isupport("EXCEPTS", "e", -1);
2502 if (ConfigChannel.use_invex)
2503 add_isupport("INVEX", "I", -1);
2504 add_isupport("CHANMODES", chanmodes, -1);
2505
2506 /*
2507 * message_locale may have changed. rebuild isupport since it relies
2508 * on strlen(form_str(RPL_ISUPPORT))
2509 */
2510 rebuild_isupport_message_line();
2511
2512 #ifdef HAVE_LIBPCRE
2513 parse_conf_file(RKLINE_TYPE, cold);
2514 parse_conf_file(RXLINE_TYPE, cold);
2515 #endif
2516 parse_conf_file(KLINE_TYPE, cold);
2517 parse_conf_file(DLINE_TYPE, cold);
2518 parse_conf_file(XLINE_TYPE, cold);
2519 parse_conf_file(NRESV_TYPE, cold);
2520 parse_conf_file(CRESV_TYPE, cold);
2521 }
2522
2523 /* parse_conf_file()
2524 *
2525 * inputs - type of conf file to parse
2526 * output - none
2527 * side effects - conf file for givenconf type is opened and read then parsed
2528 */
2529 static void
2530 parse_conf_file(int type, int cold)
2531 {
2532 FBFILE *file = NULL;
2533 const char *filename = get_conf_name(type);
2534
2535 if ((file = fbopen(filename, "r")) == NULL)
2536 {
2537 if (cold)
2538 ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
2539 filename, strerror(errno));
2540 else
2541 sendto_realops_flags(UMODE_ALL, L_ALL,
2542 "Unable to read configuration file '%s': %s",
2543 filename, strerror(errno));
2544 }
2545 else
2546 {
2547 parse_csv_file(file, type);
2548 fbclose(file);
2549 }
2550 }
2551
2552 /* clear_out_old_conf()
2553 *
2554 * inputs - none
2555 * output - none
2556 * side effects - Clear out the old configuration
2557 */
2558 static void
2559 clear_out_old_conf(void)
2560 {
2561 dlink_node *ptr = NULL, *next_ptr = NULL;
2562 struct ConfItem *conf;
2563 struct AccessItem *aconf;
2564 struct ClassItem *cltmp;
2565 struct MatchItem *match_item;
2566 dlink_list *free_items [] = {
2567 &server_items, &oconf_items, &hub_items, &leaf_items,
2568 &uconf_items, &xconf_items, &rxconf_items, &rkconf_items,
2569 &nresv_items, &cluster_items, &gdeny_items, &service_items, NULL
2570 };
2571
2572 dlink_list ** iterator = free_items; /* C is dumb */
2573
2574 /* We only need to free anything allocated by yyparse() here.
2575 * Resetting structs, etc, is taken care of by set_default_conf().
2576 */
2577
2578 for (; *iterator != NULL; iterator++)
2579 {
2580 DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
2581 {
2582 conf = ptr->data;
2583 /* XXX This is less than pretty */
2584 if (conf->type == SERVER_TYPE)
2585 {
2586 aconf = map_to_conf(conf);
2587
2588 if (aconf->clients != 0)
2589 {
2590 SetConfIllegal(aconf);
2591 dlinkDelete(&conf->node, &server_items);
2592 }
2593 else
2594 {
2595 delete_conf_item(conf);
2596 }
2597 }
2598 else if (conf->type == OPER_TYPE)
2599 {
2600 aconf = map_to_conf(conf);
2601
2602 if (aconf->clients != 0)
2603 {
2604 SetConfIllegal(aconf);
2605 dlinkDelete(&conf->node, &oconf_items);
2606 }
2607 else
2608 {
2609 delete_conf_item(conf);
2610 }
2611 }
2612 else if (conf->type == CLIENT_TYPE)
2613 {
2614 aconf = map_to_conf(conf);
2615
2616 if (aconf->clients != 0)
2617 {
2618 SetConfIllegal(aconf);
2619 }
2620 else
2621 {
2622 delete_conf_item(conf);
2623 }
2624 }
2625 else if (conf->type == XLINE_TYPE ||
2626 conf->type == RXLINE_TYPE ||
2627 conf->type == RKLINE_TYPE)
2628 {
2629 /* temporary (r)xlines are also on
2630 * the (r)xconf items list */
2631 if (conf->flags & CONF_FLAGS_TEMPORARY)
2632 continue;
2633
2634 delete_conf_item(conf);
2635 }
2636 else
2637 {
2638 if ((conf->type == LEAF_TYPE) || (conf->type == HUB_TYPE))
2639 {
2640 match_item = map_to_conf(conf);
2641 if (match_item->ref_count <= 0)
2642 delete_conf_item(conf);
2643 else
2644 {
2645 match_item->illegal = 1;
2646 dlinkDelete(&conf->node, *iterator);
2647 }
2648 }
2649 else
2650 delete_conf_item(conf);
2651 }
2652 }
2653 }
2654
2655 /*
2656 * don't delete the class table, rather mark all entries
2657 * for deletion. The table is cleaned up by check_class. - avalon
2658 */
2659 DLINK_FOREACH(ptr, class_items.head)
2660 {
2661 cltmp = map_to_conf(ptr->data);
2662
2663 if (ptr != class_items.tail) /* never mark the "default" class */
2664 cltmp->active = 0;
2665 }
2666
2667 clear_out_address_conf();
2668
2669 /* clean out module paths */
2670 mod_clear_paths();
2671
2672 /* clean out ServerInfo */
2673 MyFree(ServerInfo.description);
2674 ServerInfo.description = NULL;
2675 MyFree(ServerInfo.network_name);
2676 ServerInfo.network_name = NULL;
2677 MyFree(ServerInfo.network_desc);
2678 ServerInfo.network_desc = NULL;
2679 MyFree(ConfigFileEntry.egdpool_path);
2680 ConfigFileEntry.egdpool_path = NULL;
2681 #ifdef HAVE_LIBCRYPTO
2682 if (ServerInfo.rsa_private_key != NULL)
2683 {
2684 RSA_free(ServerInfo.rsa_private_key);
2685 ServerInfo.rsa_private_key = NULL;
2686 }
2687
2688 MyFree(ServerInfo.rsa_private_key_file);
2689 ServerInfo.rsa_private_key_file = NULL;
2690
2691 if (ServerInfo.server_ctx)
2692 SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv2|
2693 SSL_OP_NO_SSLv3|
2694 SSL_OP_NO_TLSv1);
2695 if (ServerInfo.client_ctx)
2696 SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv2|
2697 SSL_OP_NO_SSLv3|
2698 SSL_OP_NO_TLSv1);
2699 #endif
2700
2701 /* clean out old resvs from the conf */
2702 clear_conf_resv();
2703
2704 /* clean out AdminInfo */
2705 MyFree(AdminInfo.name);
2706 AdminInfo.name = NULL;
2707 MyFree(AdminInfo.email);
2708 AdminInfo.email = NULL;
2709 MyFree(AdminInfo.description);
2710 AdminInfo.description = NULL;
2711
2712 /* operator{} and class{} blocks are freed above */
2713 /* clean out listeners */
2714 close_listeners();
2715
2716 /* auth{}, quarantine{}, shared{}, connect{}, kill{}, deny{},
2717 * exempt{} and gecos{} blocks are freed above too
2718 */
2719
2720 /* clean out general */
2721 MyFree(ConfigFileEntry.service_name);
2722 ConfigFileEntry.service_name = NULL;
2723
2724 delete_isupport("INVEX");
2725 delete_isupport("EXCEPTS");
2726 }
2727
2728 /* flush_deleted_I_P()
2729 *
2730 * inputs - none
2731 * output - none
2732 * side effects - This function removes I/P conf items
2733 */
2734 static void
2735 flush_deleted_I_P(void)
2736 {
2737 dlink_node *ptr;
2738 dlink_node *next_ptr;
2739 struct ConfItem *conf;
2740 struct AccessItem *aconf;
2741 dlink_list * free_items [] = {
2742 &server_items, &oconf_items, NULL
2743 };
2744 dlink_list ** iterator = free_items; /* C is dumb */
2745
2746 /* flush out deleted I and P lines
2747 * although still in use.
2748 */
2749 for (; *iterator != NULL; iterator++)
2750 {
2751 DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
2752 {
2753 conf = ptr->data;
2754 aconf = (struct AccessItem *)map_to_conf(conf);
2755
2756 if (IsConfIllegal(aconf))
2757 {
2758 dlinkDelete(ptr, *iterator);
2759
2760 if (aconf->clients == 0)
2761 delete_conf_item(conf);
2762 }
2763 }
2764 }
2765 }
2766
2767 /* get_conf_name()
2768 *
2769 * inputs - type of conf file to return name of file for
2770 * output - pointer to filename for type of conf
2771 * side effects - none
2772 */
2773 const char *
2774 get_conf_name(ConfType type)
2775 {
2776 switch (type)
2777 {
2778 case CONF_TYPE:
2779 return ConfigFileEntry.configfile;
2780 break;
2781 case KLINE_TYPE:
2782 return ConfigFileEntry.klinefile;
2783 break;
2784 case RKLINE_TYPE:
2785 return ConfigFileEntry.rklinefile;
2786 break;
2787 case DLINE_TYPE:
2788 return ConfigFileEntry.dlinefile;
2789 break;
2790 case XLINE_TYPE:
2791 return ConfigFileEntry.xlinefile;
2792 break;
2793 case RXLINE_TYPE:
2794 return ConfigFileEntry.rxlinefile;
2795 break;
2796 case CRESV_TYPE:
2797 return ConfigFileEntry.cresvfile;
2798 break;
2799 case NRESV_TYPE:
2800 return ConfigFileEntry.nresvfile;
2801 break;
2802 case GLINE_TYPE:
2803 return ConfigFileEntry.glinefile;
2804 break;
2805
2806 default:
2807 return NULL; /* This should NEVER HAPPEN since we call this function
2808 only with the above values, this will cause us to core
2809 at some point if this happens so we know where it was */
2810 }
2811 }
2812
2813 #define BAD_PING (-1)
2814
2815 /* get_conf_ping()
2816 *
2817 * inputs - pointer to struct AccessItem
2818 * - pointer to a variable that receives ping warning time
2819 * output - ping frequency
2820 * side effects - NONE
2821 */
2822 static int
2823 get_conf_ping(struct ConfItem *conf, int *pingwarn)
2824 {
2825 struct ClassItem *aclass;
2826 struct AccessItem *aconf;
2827
2828 if (conf != NULL)
2829 {
2830 aconf = (struct AccessItem *)map_to_conf(conf);
2831 if (aconf->class_ptr != NULL)
2832 {
2833 aclass = (struct ClassItem *)map_to_conf(aconf->class_ptr);
2834 *pingwarn = PingWarning(aclass);
2835 return PingFreq(aclass);
2836 }
2837 }
2838
2839 return BAD_PING;
2840 }
2841
2842 /* get_client_class()
2843 *
2844 * inputs - pointer to client struct
2845 * output - pointer to name of class
2846 * side effects - NONE
2847 */
2848 const char *
2849 get_client_class(struct Client *target_p)
2850 {
2851 dlink_node *ptr;
2852 struct ConfItem *conf;
2853 struct AccessItem *aconf;
2854
2855 if (target_p != NULL && !IsMe(target_p) &&
2856 target_p->localClient->confs.head != NULL)
2857 {
2858 DLINK_FOREACH(ptr, target_p->localClient->confs.head)
2859 {
2860 conf = ptr->data;
2861
2862 if (conf->type == CLIENT_TYPE || conf->type == SERVER_TYPE ||
2863 conf->type == OPER_TYPE)
2864 {
2865 aconf = (struct AccessItem *) map_to_conf(conf);
2866 if (aconf->class_ptr != NULL)
2867 return aconf->class_ptr->name;
2868 }
2869 }
2870 }
2871
2872 return "default";
2873 }
2874
2875 /* get_client_ping()
2876 *
2877 * inputs - pointer to client struct
2878 * - pointer to a variable that receives ping warning time
2879 * output - ping frequency
2880 * side effects - NONE
2881 */
2882 int
2883 get_client_ping(struct Client *target_p, int *pingwarn)
2884 {
2885 int ping;
2886 struct ConfItem *conf;
2887 dlink_node *nlink;
2888
2889 if (target_p->localClient->confs.head != NULL)
2890 DLINK_FOREACH(nlink, target_p->localClient->confs.head)
2891 {
2892 conf = nlink->data;
2893
2894 if ((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
2895 (conf->type == OPER_TYPE))
2896 {
2897 ping = get_conf_ping(conf, pingwarn);
2898 if (ping > 0)
2899 return ping;
2900 }
2901 }
2902
2903 *pingwarn = 0;
2904 return DEFAULT_PINGFREQUENCY;
2905 }
2906
2907 /* find_class()
2908 *
2909 * inputs - string name of class
2910 * output - corresponding Class pointer
2911 * side effects - NONE
2912 */
2913 struct ConfItem *
2914 find_class(const char *classname)
2915 {
2916 struct ConfItem *conf;
2917
2918 if ((conf = find_exact_name_conf(CLASS_TYPE, NULL, classname, NULL, NULL)) != NULL)
2919 return conf;
2920
2921 return class_default;
2922 }
2923
2924 /* check_class()
2925 *
2926 * inputs - NONE
2927 * output - NONE
2928 * side effects -
2929 */
2930 void
2931 check_class(void)
2932 {
2933 dlink_node *ptr = NULL, *next_ptr = NULL;
2934
2935 DLINK_FOREACH_SAFE(ptr, next_ptr, class_items.head)
2936 {
2937 struct ClassItem *aclass = map_to_conf(ptr->data);
2938
2939 if (!aclass->active && !CurrUserCount(aclass))
2940 {
2941 destroy_cidr_class(aclass);
2942 delete_conf_item(ptr->data);
2943 }
2944 }
2945 }
2946
2947 /* init_class()
2948 *
2949 * inputs - NONE
2950 * output - NONE
2951 * side effects -
2952 */
2953 void
2954 init_class(void)
2955 {
2956 struct ClassItem *aclass;
2957
2958 class_default = make_conf_item(CLASS_TYPE);
2959
2960 aclass = map_to_conf(class_default);
2961 aclass->active = 1;
2962 DupString(class_default->name, "default");
2963 ConFreq(aclass) = DEFAULT_CONNECTFREQUENCY;
2964 PingFreq(aclass) = DEFAULT_PINGFREQUENCY;
2965 MaxTotal(aclass) = MAXIMUM_LINKS_DEFAULT;
2966 MaxSendq(aclass) = DEFAULT_SENDQ;
2967
2968 client_check_cb = register_callback("check_client", check_client);
2969 }
2970
2971 /* get_sendq()
2972 *
2973 * inputs - pointer to client
2974 * output - sendq for this client as found from its class
2975 * side effects - NONE
2976 */
2977 unsigned int
2978 get_sendq(struct Client *client_p)
2979 {
2980 unsigned int sendq = DEFAULT_SENDQ;
2981 dlink_node *ptr;
2982 struct ConfItem *conf;
2983 struct ConfItem *class_conf;
2984 struct ClassItem *aclass;
2985 struct AccessItem *aconf;
2986
2987 if (client_p && !IsMe(client_p) && (client_p->localClient->confs.head))
2988 {
2989 DLINK_FOREACH(ptr, client_p->localClient->confs.head)
2990 {
2991 conf = ptr->data;
2992 if ((conf->type == SERVER_TYPE) || (conf->type == OPER_TYPE)
2993 || (conf->type == CLIENT_TYPE))
2994 {
2995 aconf = (struct AccessItem *)map_to_conf(conf);
2996 if ((class_conf = aconf->class_ptr) == NULL)
2997 continue;
2998 aclass = (struct ClassItem *)map_to_conf(class_conf);
2999 sendq = MaxSendq(aclass);
3000 return sendq;
3001 }
3002 }
3003 }
3004 /* XXX return a default?
3005 * if here, then there wasn't an attached conf with a sendq
3006 * that is very bad -Dianora
3007 */
3008 return DEFAULT_SENDQ;
3009 }
3010
3011 /* conf_add_class_to_conf()
3012 *
3013 * inputs - pointer to config item
3014 * output - NONE
3015 * side effects - Add a class pointer to a conf
3016 */
3017 void
3018 conf_add_class_to_conf(struct ConfItem *conf, const char *class_name)
3019 {
3020 struct AccessItem *aconf = map_to_conf(conf);
3021 struct ClassItem *class = NULL;
3022
3023 if (class_name == NULL)
3024 {
3025 aconf->class_ptr = class_default;
3026
3027 if (conf->type == CLIENT_TYPE)
3028 sendto_realops_flags(UMODE_ALL, L_ALL,
3029 "Warning *** Defaulting to default class for %s@%s",
3030 aconf->user, aconf->host);
3031 else
3032 sendto_realops_flags(UMODE_ALL, L_ALL,
3033 "Warning *** Defaulting to default class for %s",
3034 conf->name);
3035 }
3036 else
3037 aconf->class_ptr = find_class(class_name);
3038
3039 if (aconf->class_ptr)
3040 class = map_to_conf(aconf->class_ptr);
3041
3042 if (aconf->class_ptr == NULL || !class->active)
3043 {
3044 if (conf->type == CLIENT_TYPE)
3045 sendto_realops_flags(UMODE_ALL, L_ALL,
3046 "Warning *** Defaulting to default class for %s@%s",
3047 aconf->user, aconf->host);
3048 else
3049 sendto_realops_flags(UMODE_ALL, L_ALL,
3050 "Warning *** Defaulting to default class for %s",
3051 conf->name);
3052 aconf->class_ptr = class_default;
3053 }
3054 }
3055
3056 /* conf_add_server()
3057 *
3058 * inputs - pointer to config item
3059 * - pointer to link count already on this conf
3060 * output - NONE
3061 * side effects - Add a connect block
3062 */
3063 int
3064 conf_add_server(struct ConfItem *conf, const char *class_name)
3065 {
3066 struct AccessItem *aconf;
3067 struct split_nuh_item nuh;
3068 char conf_user[USERLEN + 1];
3069 char conf_host[HOSTLEN + 1];
3070
3071 aconf = map_to_conf(conf);
3072
3073 conf_add_class_to_conf(conf, class_name);
3074
3075 if (!aconf->host || !conf->name)
3076 {
3077 sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block");
3078 ilog(LOG_TYPE_IRCD, "Bad connect block");
3079 return -1;
3080 }
3081
3082 if (EmptyString(aconf->passwd))
3083 {
3084 sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block, name %s",
3085 conf->name);
3086 ilog(LOG_TYPE_IRCD, "Bad connect block, host %s", conf->name);
3087 return -1;
3088 }
3089
3090 nuh.nuhmask = aconf->host;
3091 nuh.nickptr = NULL;
3092 nuh.userptr = conf_user;
3093 nuh.hostptr = conf_host;
3094
3095 nuh.nicksize = 0;
3096 nuh.usersize = sizeof(conf_user);
3097 nuh.hostsize = sizeof(conf_host);
3098
3099 split_nuh(&nuh);
3100
3101 MyFree(aconf->host);
3102 aconf->host = NULL;
3103
3104 DupString(aconf->user, conf_user); /* somehow username checking for servers
3105 got lost in H6/7, will have to be re-added */
3106 DupString(aconf->host, conf_host);
3107
3108 lookup_confhost(conf);
3109
3110 return 0;
3111 }
3112
3113 /* yyerror()
3114 *
3115 * inputs - message from parser
3116 * output - NONE
3117 * side effects - message to opers and log file entry is made
3118 */
3119 void
3120 yyerror(const char *msg)
3121 {
3122 char newlinebuf[IRCD_BUFSIZE];
3123
3124 if (conf_parser_ctx.pass != 1)
3125 return;
3126
3127 strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
3128 sendto_realops_flags(UMODE_ALL, L_ALL, "\"%s\", line %u: %s: %s",
3129 conffilebuf, lineno + 1, msg, newlinebuf);
3130 ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
3131 conffilebuf, lineno + 1, msg, newlinebuf);
3132 }
3133
3134 int
3135 conf_fbgets(char *lbuf, unsigned int max_size, FBFILE *fb)
3136 {
3137 if (fbgets(lbuf, max_size, fb) == NULL)
3138 return 0;
3139
3140 return strlen(lbuf);
3141 }
3142
3143 int
3144 conf_yy_fatal_error(const char *msg)
3145 {
3146 return 0;
3147 }
3148
3149 /*
3150 * valid_tkline()
3151 *
3152 * inputs - pointer to ascii string to check
3153 * - whether the specified time is in seconds or minutes
3154 * output - -1 not enough parameters
3155 * - 0 if not an integer number, else the number
3156 * side effects - none
3157 * Originally written by Dianora (Diane, db@db.net)
3158 */
3159 time_t
3160 valid_tkline(const char *p, int minutes)
3161 {
3162 time_t result = 0;
3163
3164 for (; *p; ++p)
3165 {
3166 if (!IsDigit(*p))
3167 return 0;
3168
3169 result *= 10;
3170 result += ((*p) & 0xF);
3171 }
3172
3173 /*
3174 * In the degenerate case where oper does a /quote kline 0 user@host :reason
3175 * i.e. they specifically use 0, I am going to return 1 instead
3176 * as a return value of non-zero is used to flag it as a temporary kline
3177 */
3178 if (result == 0)
3179 result = 1;
3180
3181 /*
3182 * If the incoming time is in seconds convert it to minutes for the purpose
3183 * of this calculation
3184 */
3185 if (!minutes)
3186 result = result / (time_t)60;
3187
3188 if (result > MAX_TDKLINE_TIME)
3189 result = MAX_TDKLINE_TIME;
3190
3191 result = result * (time_t)60; /* turn it into seconds */
3192
3193 return result;
3194 }
3195
3196 /* valid_wild_card()
3197 *
3198 * input - pointer to client
3199 * - int flag, 0 for no warning oper 1 for warning oper
3200 * - count of following varargs to check
3201 * output - 0 if not valid, 1 if valid
3202 * side effects - NOTICE is given to source_p if warn is 1
3203 */
3204 int
3205 valid_wild_card(struct Client *source_p, int warn, int count, ...)
3206 {
3207 char *p;
3208 char tmpch;
3209 int nonwild = 0;
3210 va_list args;
3211
3212 /*
3213 * Now we must check the user and host to make sure there
3214 * are at least NONWILDCHARS non-wildcard characters in
3215 * them, otherwise assume they are attempting to kline
3216 * *@* or some variant of that. This code will also catch
3217 * people attempting to kline *@*.tld, as long as NONWILDCHARS
3218 * is greater than 3. In that case, there are only 3 non-wild
3219 * characters (tld), so if NONWILDCHARS is 4, the kline will
3220 * be disallowed.
3221 * -wnder
3222 */
3223
3224 va_start(args, count);
3225
3226 while (count--)
3227 {
3228 p = va_arg(args, char *);
3229 if (p == NULL)
3230 continue;
3231
3232 while ((tmpch = *p++))
3233 {
3234 if (!IsKWildChar(tmpch))
3235 {
3236 /*
3237 * If we find enough non-wild characters, we can
3238 * break - no point in searching further.
3239 */
3240 if (++nonwild >= ConfigFileEntry.min_nonwildcard)
3241 return 1;
3242 }
3243 }
3244 }
3245
3246 if (warn)
3247 sendto_one(source_p, ":%s NOTICE %s :Please include at least %d non-wildcard characters with the mask",
3248 me.name, source_p->name, ConfigFileEntry.min_nonwildcard);
3249 return 0;
3250 }
3251
3252 /* XXX should this go into a separate file ? -Dianora */
3253 /* parse_aline
3254 *
3255 * input - pointer to cmd name being used
3256 * - pointer to client using cmd
3257 * - parc parameter count
3258 * - parv[] list of parameters to parse
3259 * - parse_flags bit map of things to test
3260 * - pointer to user or string to parse into
3261 * - pointer to host or NULL to parse into if non NULL
3262 * - pointer to optional tkline time or NULL
3263 * - pointer to target_server to parse into if non NULL
3264 * - pointer to reason to parse into
3265 *
3266 * output - 1 if valid, -1 if not valid
3267 * side effects - A generalised k/d/x etc. line parser,
3268 * "ALINE [time] user@host|string [ON] target :reason"
3269 * will parse returning a parsed user, host if
3270 * h_p pointer is non NULL, string otherwise.
3271 * if tkline_time pointer is non NULL a tk line will be set
3272 * to non zero if found.
3273 * if tkline_time pointer is NULL and tk line is found,
3274 * error is reported.
3275 * if target_server is NULL and an "ON" is found error
3276 * is reported.
3277 * if reason pointer is NULL ignore pointer,
3278 * this allows use of parse_a_line in unkline etc.
3279 *
3280 * - Dianora
3281 */
3282 int
3283 parse_aline(const char *cmd, struct Client *source_p,
3284 int parc, char **parv,
3285 int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
3286 char **target_server, char **reason)
3287 {
3288 int found_tkline_time=0;
3289 static char def_reason[] = "No Reason";
3290 static char user[USERLEN*4+1];
3291 static char host[HOSTLEN*4+1];
3292
3293 parv++;
3294 parc--;
3295
3296 found_tkline_time = valid_tkline(*parv, TK_MINUTES);
3297
3298 if (found_tkline_time != 0)
3299 {
3300 parv++;
3301 parc--;
3302
3303 if (tkline_time != NULL)
3304 *tkline_time = found_tkline_time;
3305 else
3306 {
3307 sendto_one(source_p, ":%s NOTICE %s :temp_line not supported by %s",
3308 me.name, source_p->name, cmd);
3309 return -1;
3310 }
3311 }
3312
3313 if (parc == 0)
3314 {
3315 sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
3316 me.name, source_p->name, cmd);
3317 return -1;
3318 }
3319
3320 if (h_p == NULL)
3321 *up_p = *parv;
3322 else
3323 {
3324 if (find_user_host(source_p, *parv, user, host, parse_flags) == 0)
3325 return -1;
3326
3327 *up_p = user;
3328 *h_p = host;
3329 }
3330
3331 parc--;
3332 parv++;
3333
3334 if (parc != 0)
3335 {
3336 if (irccmp(*parv, "ON") == 0)
3337 {
3338 parc--;
3339 parv++;
3340
3341 if (target_server == NULL)
3342 {
3343 sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
3344 me.name, source_p->name, cmd);
3345 return -1;
3346 }
3347
3348 if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
3349 {
3350 sendto_one(source_p, form_str(ERR_NOPRIVS),
3351 me.name, source_p->name, "remoteban");
3352 return -1;
3353 }
3354
3355 if (parc == 0 || EmptyString(*parv))
3356 {
3357 sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
3358 me.name, source_p->name, cmd);
3359 return -1;
3360 }
3361
3362 *target_server = *parv;
3363 parc--;
3364 parv++;
3365 }
3366 else
3367 {
3368 /* Make sure target_server *is* NULL if no ON server found
3369 * caller probably NULL'd it first, but no harm to do it again -db
3370 */
3371 if (target_server != NULL)
3372 *target_server = NULL;
3373 }
3374 }
3375
3376 if (h_p != NULL)
3377 {
3378 if (strchr(user, '!') != NULL)
3379 {
3380 sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
3381 me.name, source_p->name);
3382 return -1;
3383 }
3384
3385 if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
3386 return -1;
3387 }
3388 else
3389 if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
3390 return -1;
3391
3392 if (reason != NULL)
3393 {
3394 if (parc != 0 && !EmptyString(*parv))
3395 {
3396 *reason = *parv;
3397 if (!valid_comment(source_p, *reason, 1))
3398 return -1;
3399 }
3400 else
3401 *reason = def_reason;
3402 }
3403
3404 return 1;
3405 }
3406
3407 /* find_user_host()
3408 *
3409 * inputs - pointer to client placing kline
3410 * - pointer to user_host_or_nick
3411 * - pointer to user buffer
3412 * - pointer to host buffer
3413 * output - 0 if not ok to kline, 1 to kline i.e. if valid user host
3414 * side effects -
3415 */
3416 static int
3417 find_user_host(struct Client *source_p, char *user_host_or_nick,
3418 char *luser, char *lhost, unsigned int flags)
3419 {
3420 struct Client *target_p = NULL;
3421 char *hostp = NULL;
3422
3423 if (lhost == NULL)
3424 {
3425 strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
3426 return 1;
3427 }
3428
3429 if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
3430 {
3431 /* Explicit user@host mask given */
3432
3433 if (hostp != NULL) /* I'm a little user@host */
3434 {
3435 *(hostp++) = '\0'; /* short and squat */
3436 if (*user_host_or_nick)
3437 strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
3438 else
3439 strcpy(luser, "*");
3440 if (*hostp)
3441 strlcpy(lhost, hostp, HOSTLEN + 1); /* here is my host */
3442 else
3443 strcpy(lhost, "*");
3444 }
3445 else
3446 {
3447 luser[0] = '*'; /* no @ found, assume its *@somehost */
3448 luser[1] = '\0';
3449 strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
3450 }
3451
3452 return 1;
3453 }
3454 else if (!(flags & NOUSERLOOKUP))
3455 {
3456 /* Try to find user@host mask from nick */
3457 /* Okay to use source_p as the first param, because source_p == client_p */
3458 if ((target_p =
3459 find_chasing(source_p, source_p, user_host_or_nick, NULL)) == NULL)
3460 return 0;
3461
3462 if (IsExemptKline(target_p))
3463 {
3464 if (!IsServer(source_p))
3465 sendto_one(source_p,
3466 ":%s NOTICE %s :%s is E-lined",
3467 me.name, source_p->name, target_p->name);
3468 return 0;
3469 }
3470
3471 /*
3472 * turn the "user" bit into "*user", blow away '~'
3473 * if found in original user name (non-idented)
3474 */
3475 strlcpy(luser, target_p->username, USERLEN*4 + 1);
3476
3477 if (target_p->username[0] == '~')
3478 luser[0] = '*';
3479
3480 if (target_p->sockhost[0] == '\0' ||
3481 (target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
3482 strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
3483 else
3484 strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
3485 return 1;
3486 }
3487
3488 return 0;
3489 }
3490
3491 /* valid_comment()
3492 *
3493 * inputs - pointer to client
3494 * - pointer to comment
3495 * output - 0 if no valid comment,
3496 * - 1 if valid
3497 * side effects - truncates reason where necessary
3498 */
3499 int
3500 valid_comment(struct Client *source_p, char *comment, int warn)
3501 {
3502 if (strchr(comment, '"'))
3503 {
3504 if (warn)
3505 sendto_one(source_p, ":%s NOTICE %s :Invalid character '\"' in comment",
3506 me.name, source_p->name);
3507 return 0;
3508 }
3509
3510 if (strlen(comment) > REASONLEN)
3511 comment[REASONLEN-1] = '\0';
3512
3513 return 1;
3514 }
3515
3516 /* match_conf_password()
3517 *
3518 * inputs - pointer to given password
3519 * - pointer to Conf
3520 * output - 1 or 0 if match
3521 * side effects - none
3522 */
3523 int
3524 match_conf_password(const char *password, const struct AccessItem *aconf)
3525 {
3526 const char *encr = NULL;
3527
3528 if (password == NULL || aconf->passwd == NULL)
3529 return 0;
3530
3531 if (aconf->flags & CONF_FLAGS_ENCRYPTED)
3532 {
3533 /* use first two chars of the password they send in as salt */
3534 /* If the password in the conf is MD5, and ircd is linked
3535 * to scrypt on FreeBSD, or the standard crypt library on
3536 * glibc Linux, then this code will work fine on generating
3537 * the proper encrypted hash for comparison.
3538 */
3539 if (*aconf->passwd)
3540 encr = crypt(password, aconf->passwd);
3541 else
3542 encr = "";
3543 }