ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-7.2/src/ircd_parser.y
Revision: 342
Committed: Tue Dec 27 19:28:58 2005 UTC (18 years, 2 months ago) by michael
File size: 88986 byte(s)
Log Message:
- Fixed compile error reported by Volk and CoolCold

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * ircd_parser.y: Parses the ircd configuration file.
4 *
5 * Copyright (C) 2005 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 %{
26
27 #define YY_NO_UNPUT
28 #include <sys/types.h>
29
30 #include "stdinc.h"
31 #include "dalloca.h"
32 #include "ircd.h"
33 #include "tools.h"
34 #include "list.h"
35 #include "s_conf.h"
36 #include "event.h"
37 #include "s_log.h"
38 #include "client.h" /* for UMODE_ALL only */
39 #include "pcre.h"
40 #include "irc_string.h"
41 #include "irc_getaddrinfo.h"
42 #include "sprintf_irc.h"
43 #include "memory.h"
44 #include "modules.h"
45 #include "s_serv.h" /* for CAP_LL / IsCapable */
46 #include "hostmask.h"
47 #include "send.h"
48 #include "listener.h"
49 #include "resv.h"
50 #include "numeric.h"
51 #include "s_user.h"
52
53 #ifdef HAVE_LIBCRYPTO
54 #include <openssl/rsa.h>
55 #include <openssl/bio.h>
56 #include <openssl/pem.h>
57 #endif
58
59 static char *class_name = NULL;
60 static struct ConfItem *yy_conf = NULL;
61 static struct AccessItem *yy_aconf = NULL;
62 static struct MatchItem *yy_match_item = NULL;
63 static struct ClassItem *yy_class = NULL;
64 static char *yy_class_name = NULL;
65
66 static dlink_list col_conf_list = { NULL, NULL, 0 };
67 static dlink_list hub_conf_list = { NULL, NULL, 0 };
68 static dlink_list leaf_conf_list = { NULL, NULL, 0 };
69 static unsigned int listener_flags = 0;
70 static unsigned int regex_ban = 0;
71 static char userbuf[IRCD_BUFSIZE];
72 static char hostbuf[IRCD_BUFSIZE];
73 static char reasonbuf[REASONLEN + 1];
74 static char gecos_name[REALLEN * 4];
75
76 extern dlink_list gdeny_items; /* XXX */
77
78 static char *resv_reason = NULL;
79 static char *listener_address = NULL;
80 static int not_atom = 0;
81
82 struct CollectItem {
83 dlink_node node;
84 char *name;
85 char *user;
86 char *host;
87 char *passwd;
88 int port;
89 int flags;
90 #ifdef HAVE_LIBCRYPTO
91 char *rsa_public_key_file;
92 RSA *rsa_public_key;
93 #endif
94 };
95
96 static void
97 free_collect_item(struct CollectItem *item)
98 {
99 MyFree(item->name);
100 MyFree(item->user);
101 MyFree(item->host);
102 MyFree(item->passwd);
103 #ifdef HAVE_LIBCRYPTO
104 MyFree(item->rsa_public_key_file);
105 #endif
106 MyFree(item);
107 }
108
109 static void
110 unhook_hub_leaf_confs(void)
111 {
112 dlink_node *ptr;
113 dlink_node *next_ptr;
114 struct CollectItem *yy_hconf;
115 struct CollectItem *yy_lconf;
116
117 DLINK_FOREACH_SAFE(ptr, next_ptr, hub_conf_list.head)
118 {
119 yy_hconf = ptr->data;
120 dlinkDelete(&yy_hconf->node, &hub_conf_list);
121 free_collect_item(yy_hconf);
122 }
123
124 DLINK_FOREACH_SAFE(ptr, next_ptr, leaf_conf_list.head)
125 {
126 yy_lconf = ptr->data;
127 dlinkDelete(&yy_lconf->node, &leaf_conf_list);
128 free_collect_item(yy_lconf);
129 }
130 }
131
132 %}
133
134 %union {
135 int number;
136 char *string;
137 }
138
139 %token ACCEPT_PASSWORD
140 %token ACTION
141 %token ADMIN
142 %token AFTYPE
143 %token T_ALLOW
144 %token ANTI_NICK_FLOOD
145 %token ANTI_SPAM_EXIT_MESSAGE_TIME
146 %token AUTOCONN
147 %token T_BLOCK
148 %token BURST_AWAY
149 %token BURST_TOPICWHO
150 %token BYTES KBYTES MBYTES GBYTES TBYTES
151 %token CALLER_ID_WAIT
152 %token CAN_FLOOD
153 %token CAN_IDLE
154 %token CHANNEL
155 %token CIDR_BITLEN_IPV4
156 %token CIDR_BITLEN_IPV6
157 %token CIPHER_PREFERENCE
158 %token CLASS
159 %token COMPRESSED
160 %token COMPRESSION_LEVEL
161 %token CONNECT
162 %token CONNECTFREQ
163 %token CRYPTLINK
164 %token DEFAULT_CIPHER_PREFERENCE
165 %token DEFAULT_FLOODCOUNT
166 %token DEFAULT_SPLIT_SERVER_COUNT
167 %token DEFAULT_SPLIT_USER_COUNT
168 %token DENY
169 %token DESCRIPTION
170 %token DIE
171 %token DISABLE_AUTH
172 %token DISABLE_HIDDEN
173 %token DISABLE_LOCAL_CHANNELS
174 %token DISABLE_REMOTE_COMMANDS
175 %token DOT_IN_IP6_ADDR
176 %token DOTS_IN_IDENT
177 %token DURATION
178 %token EGDPOOL_PATH
179 %token EMAIL
180 %token ENABLE
181 %token ENCRYPTED
182 %token EXCEED_LIMIT
183 %token EXEMPT
184 %token FAILED_OPER_NOTICE
185 %token FAKENAME
186 %token IRCD_FLAGS
187 %token FLATTEN_LINKS
188 %token FFAILED_OPERLOG
189 %token FKILLLOG
190 %token FKLINELOG
191 %token FGLINELOG
192 %token FIOERRLOG
193 %token FOPERLOG
194 %token FOPERSPYLOG
195 %token FUSERLOG
196 %token GECOS
197 %token GENERAL
198 %token GLINE
199 %token GLINES
200 %token GLINE_EXEMPT
201 %token GLINE_LOG
202 %token GLINE_TIME
203 %token GLINE_MIN_CIDR
204 %token GLINE_MIN_CIDR6
205 %token GLOBAL_KILL
206 %token IRCD_AUTH
207 %token NEED_IDENT
208 %token HAVENT_READ_CONF
209 %token HIDDEN
210 %token HIDDEN_ADMIN
211 %token HIDDEN_NAME
212 %token HIDDEN_OPER
213 %token HIDE_SERVER_IPS
214 %token HIDE_SERVERS
215 %token HIDE_SPOOF_IPS
216 %token HOST
217 %token HUB
218 %token HUB_MASK
219 %token IDLETIME
220 %token IGNORE_BOGUS_TS
221 %token INVISIBLE_ON_CONNECT
222 %token IP
223 %token KILL
224 %token KILL_CHASE_TIME_LIMIT
225 %token KLINE
226 %token KLINE_EXEMPT
227 %token KLINE_REASON
228 %token KLINE_WITH_REASON
229 %token KNOCK_DELAY
230 %token KNOCK_DELAY_CHANNEL
231 %token LAZYLINK
232 %token LEAF_MASK
233 %token LINKS_DELAY
234 %token LISTEN
235 %token T_LOG
236 %token LOGGING
237 %token LOG_LEVEL
238 %token MAX_ACCEPT
239 %token MAX_BANS
240 %token MAX_CHANS_PER_USER
241 %token MAX_GLOBAL
242 %token MAX_IDENT
243 %token MAX_LOCAL
244 %token MAX_NICK_CHANGES
245 %token MAX_NICK_TIME
246 %token MAX_NUMBER
247 %token MAX_TARGETS
248 %token MESSAGE_LOCALE
249 %token MIN_NONWILDCARD
250 %token MIN_NONWILDCARD_SIMPLE
251 %token MODULE
252 %token MODULES
253 %token NAME
254 %token NEED_PASSWORD
255 %token NETWORK_DESC
256 %token NETWORK_NAME
257 %token NICK
258 %token NICK_CHANGES
259 %token NO_CREATE_ON_SPLIT
260 %token NO_JOIN_ON_SPLIT
261 %token NO_OPER_FLOOD
262 %token NO_TILDE
263 %token NOT
264 %token NUMBER
265 %token NUMBER_PER_IDENT
266 %token NUMBER_PER_CIDR
267 %token NUMBER_PER_IP
268 %token NUMBER_PER_IP_GLOBAL
269 %token OPERATOR
270 %token OPERS_BYPASS_CALLERID
271 %token OPER_LOG
272 %token OPER_ONLY_UMODES
273 %token OPER_PASS_RESV
274 %token OPER_SPY_T
275 %token OPER_UMODES
276 %token JOIN_FLOOD_COUNT
277 %token JOIN_FLOOD_TIME
278 %token PACE_WAIT
279 %token PACE_WAIT_SIMPLE
280 %token PASSWORD
281 %token PATH
282 %token PING_COOKIE
283 %token PING_TIME
284 %token PING_WARNING
285 %token PORT
286 %token QSTRING
287 %token QUIET_ON_BAN
288 %token REASON
289 %token REDIRPORT
290 %token REDIRSERV
291 %token REGEX_T
292 %token REHASH
293 %token TREJECT_HOLD_TIME
294 %token REMOTE
295 %token REMOTEBAN
296 %token RESTRICT_CHANNELS
297 %token RESTRICTED
298 %token RSA_PRIVATE_KEY_FILE
299 %token RSA_PUBLIC_KEY_FILE
300 %token SSL_CERTIFICATE_FILE
301 %token RESV
302 %token RESV_EXEMPT
303 %token SECONDS MINUTES HOURS DAYS WEEKS
304 %token SENDQ
305 %token SEND_PASSWORD
306 %token SERVERHIDE
307 %token SERVERINFO
308 %token SERVLINK_PATH
309 %token IRCD_SID
310 %token TKLINE_EXPIRE_NOTICES
311 %token T_SHARED
312 %token T_CLUSTER
313 %token TYPE
314 %token SHORT_MOTD
315 %token SILENT
316 %token SPOOF
317 %token SPOOF_NOTICE
318 %token STATS_I_OPER_ONLY
319 %token STATS_K_OPER_ONLY
320 %token STATS_O_OPER_ONLY
321 %token STATS_P_OPER_ONLY
322 %token TBOOL
323 %token TMASKED
324 %token T_REJECT
325 %token TS_MAX_DELTA
326 %token TS_WARN_DELTA
327 %token TWODOTS
328 %token T_ALL
329 %token T_BOTS
330 %token T_SOFTCALLERID
331 %token T_CALLERID
332 %token T_CCONN
333 %token T_CLIENT_FLOOD
334 %token T_DEAF
335 %token T_DEBUG
336 %token T_DRONE
337 %token T_EXTERNAL
338 %token T_FULL
339 %token T_INVISIBLE
340 %token T_IPV4
341 %token T_IPV6
342 %token T_LOCOPS
343 %token T_LOGPATH
344 %token T_L_CRIT
345 %token T_L_DEBUG
346 %token T_L_ERROR
347 %token T_L_INFO
348 %token T_L_NOTICE
349 %token T_L_TRACE
350 %token T_L_WARN
351 %token T_MAX_CLIENTS
352 %token T_NCHANGE
353 %token T_OPERWALL
354 %token T_REJ
355 %token T_SERVNOTICE
356 %token T_SKILL
357 %token T_SPY
358 %token T_SSL
359 %token T_UMODES
360 %token T_UNAUTH
361 %token T_UNRESV
362 %token T_UNXLINE
363 %token T_WALLOP
364 %token THROTTLE_TIME
365 %token TOPICBURST
366 %token TRUE_NO_OPER_FLOOD
367 %token TKLINE
368 %token TXLINE
369 %token TRESV
370 %token UNKLINE
371 %token USER
372 %token USE_EGD
373 %token USE_EXCEPT
374 %token USE_INVEX
375 %token USE_KNOCK
376 %token USE_LOGGING
377 %token USE_WHOIS_ACTUALLY
378 %token VHOST
379 %token VHOST6
380 %token XLINE
381 %token WARN
382 %token WARN_NO_NLINE
383
384 %type <string> QSTRING
385 %type <number> NUMBER
386 %type <number> timespec
387 %type <number> timespec_
388 %type <number> sizespec
389 %type <number> sizespec_
390
391 %%
392 conf:
393 | conf conf_item
394 ;
395
396 conf_item: admin_entry
397 | logging_entry
398 | oper_entry
399 | channel_entry
400 | class_entry
401 | listen_entry
402 | auth_entry
403 | serverinfo_entry
404 | serverhide_entry
405 | resv_entry
406 | shared_entry
407 | cluster_entry
408 | connect_entry
409 | kill_entry
410 | deny_entry
411 | exempt_entry
412 | general_entry
413 | gline_entry
414 | gecos_entry
415 | modules_entry
416 | error ';'
417 | error '}'
418 ;
419
420
421 timespec_: { $$ = 0; } | timespec;
422 timespec: NUMBER timespec_
423 {
424 $$ = $1 + $2;
425 }
426 | NUMBER SECONDS timespec_
427 {
428 $$ = $1 + $3;
429 }
430 | NUMBER MINUTES timespec_
431 {
432 $$ = $1 * 60 + $3;
433 }
434 | NUMBER HOURS timespec_
435 {
436 $$ = $1 * 60 * 60 + $3;
437 }
438 | NUMBER DAYS timespec_
439 {
440 $$ = $1 * 60 * 60 * 24 + $3;
441 }
442 | NUMBER WEEKS timespec_
443 {
444 $$ = $1 * 60 * 60 * 24 * 7 + $3;
445 }
446 ;
447
448 sizespec_: { $$ = 0; } | sizespec;
449 sizespec: NUMBER sizespec_ { $$ = $1 + $2; }
450 | NUMBER BYTES sizespec_ { $$ = $1 + $3; }
451 | NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; }
452 | NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
453 ;
454
455
456 /***************************************************************************
457 * section modules
458 ***************************************************************************/
459 modules_entry: MODULES
460 '{' modules_items '}' ';';
461
462 modules_items: modules_items modules_item | modules_item;
463 modules_item: modules_module | modules_path | error ';' ;
464
465 modules_module: MODULE '=' QSTRING ';'
466 {
467 #ifndef STATIC_MODULES /* NOOP in the static case */
468 if (ypass == 2)
469 {
470 char *m_bn;
471
472 m_bn = basename(yylval.string);
473
474 /* I suppose we should just ignore it if it is already loaded(since
475 * otherwise we would flood the opers on rehash) -A1kmm.
476 */
477 add_conf_module(yylval.string);
478 }
479 #endif
480 };
481
482 modules_path: PATH '=' QSTRING ';'
483 {
484 #ifndef STATIC_MODULES
485 if (ypass == 2)
486 mod_add_path(yylval.string);
487 #endif
488 };
489
490 /***************************************************************************
491 * section serverinfo
492 ***************************************************************************/
493 serverinfo_entry: SERVERINFO
494 '{' serverinfo_items '}' ';';
495
496 serverinfo_items: serverinfo_items serverinfo_item |
497 serverinfo_item ;
498 serverinfo_item: serverinfo_name | serverinfo_vhost |
499 serverinfo_hub | serverinfo_description |
500 serverinfo_network_name | serverinfo_network_desc |
501 serverinfo_max_clients |
502 serverinfo_rsa_private_key_file | serverinfo_vhost6 |
503 serverinfo_sid | serverinfo_ssl_certificate_file |
504 error ';' ;
505
506 serverinfo_ssl_certificate_file: SSL_CERTIFICATE_FILE '=' QSTRING ';'
507 {
508 #ifdef HAVE_LIBCRYPTO
509 if (ypass == 2 && ServerInfo.ctx)
510 {
511 if (!ServerInfo.rsa_private_key_file)
512 {
513 yyerror("No rsa_private_key_file specified, SSL disabled");
514 break;
515 }
516
517 if (SSL_CTX_use_certificate_file(ServerInfo.ctx,
518 yylval.string, SSL_FILETYPE_PEM) <= 0)
519 {
520 yyerror(ERR_lib_error_string(ERR_get_error()));
521 break;
522 }
523
524 if (SSL_CTX_use_PrivateKey_file(ServerInfo.ctx,
525 ServerInfo.rsa_private_key_file, SSL_FILETYPE_PEM) <= 0)
526 {
527 yyerror(ERR_lib_error_string(ERR_get_error()));
528 break;
529 }
530
531 if (!SSL_CTX_check_private_key(ServerInfo.ctx))
532 {
533 yyerror("RSA private key does not match the SSL certificate public key!");
534 break;
535 }
536 }
537 #endif
538 };
539
540 serverinfo_rsa_private_key_file: RSA_PRIVATE_KEY_FILE '=' QSTRING ';'
541 {
542 #ifdef HAVE_LIBCRYPTO
543 if (ypass == 1)
544 {
545 BIO *file;
546
547 if (ServerInfo.rsa_private_key)
548 {
549 RSA_free(ServerInfo.rsa_private_key);
550 ServerInfo.rsa_private_key = NULL;
551 }
552
553 if (ServerInfo.rsa_private_key_file)
554 {
555 MyFree(ServerInfo.rsa_private_key_file);
556 ServerInfo.rsa_private_key_file = NULL;
557 }
558
559 DupString(ServerInfo.rsa_private_key_file, yylval.string);
560
561 if ((file = BIO_new_file(yylval.string, "r")) == NULL)
562 {
563 yyerror("File open failed, ignoring");
564 break;
565 }
566
567 ServerInfo.rsa_private_key = (RSA *)PEM_read_bio_RSAPrivateKey(file, NULL,
568 0, NULL);
569
570 BIO_set_close(file, BIO_CLOSE);
571 BIO_free(file);
572
573 if (ServerInfo.rsa_private_key == NULL)
574 {
575 yyerror("Couldn't extract key, ignoring");
576 break;
577 }
578
579 if (!RSA_check_key(ServerInfo.rsa_private_key))
580 {
581 RSA_free(ServerInfo.rsa_private_key);
582 ServerInfo.rsa_private_key = NULL;
583
584 yyerror("Invalid key, ignoring");
585 break;
586 }
587
588 /* require 2048 bit (256 byte) key */
589 if (RSA_size(ServerInfo.rsa_private_key) != 256)
590 {
591 RSA_free(ServerInfo.rsa_private_key);
592 ServerInfo.rsa_private_key = NULL;
593
594 yyerror("Not a 2048 bit key, ignoring");
595 }
596 }
597 #endif
598 };
599
600 serverinfo_name: NAME '=' QSTRING ';'
601 {
602 /* this isn't rehashable */
603 if (ypass == 2)
604 {
605 if (ServerInfo.name == NULL)
606 {
607 /* the ircd will exit() in main() if we dont set one */
608 if (strlen(yylval.string) <= HOSTLEN)
609 DupString(ServerInfo.name, yylval.string);
610 }
611 }
612 };
613
614 serverinfo_sid: IRCD_SID '=' QSTRING ';'
615 {
616 /* this isn't rehashable */
617 if (ypass == 2 && !ServerInfo.sid)
618 {
619 if ((strlen(yylval.string) == IRC_MAXSID) && IsDigit(yylval.string[0])
620 && IsAlNum(yylval.string[1]) && IsAlNum(yylval.string[2]))
621 {
622 DupString(ServerInfo.sid, yylval.string);
623 }
624 else
625 {
626 ilog(L_ERROR, "Ignoring config file entry SID -- invalid SID. Aborting.");
627 exit(0);
628 }
629 }
630 };
631
632 serverinfo_description: DESCRIPTION '=' QSTRING ';'
633 {
634 if (ypass == 2)
635 {
636 MyFree(ServerInfo.description);
637 DupString(ServerInfo.description,yylval.string);
638 }
639 };
640
641 serverinfo_network_name: NETWORK_NAME '=' QSTRING ';'
642 {
643 if (ypass == 2)
644 {
645 char *p;
646
647 if ((p = strchr(yylval.string, ' ')) != NULL)
648 p = '\0';
649
650 MyFree(ServerInfo.network_name);
651 DupString(ServerInfo.network_name, yylval.string);
652 }
653 };
654
655 serverinfo_network_desc: NETWORK_DESC '=' QSTRING ';'
656 {
657 if (ypass == 2)
658 {
659 MyFree(ServerInfo.network_desc);
660 DupString(ServerInfo.network_desc, yylval.string);
661 }
662 };
663
664 serverinfo_vhost: VHOST '=' QSTRING ';'
665 {
666 if (ypass == 2 && *yylval.string != '*')
667 {
668 struct addrinfo hints, *res;
669
670 memset(&hints, 0, sizeof(hints));
671
672 hints.ai_family = AF_UNSPEC;
673 hints.ai_socktype = SOCK_STREAM;
674 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
675
676 if (irc_getaddrinfo(yylval.string, NULL, &hints, &res))
677 ilog(L_ERROR, "Invalid netmask for server vhost(%s)", yylval.string);
678 else
679 {
680 assert(res != NULL);
681
682 memcpy(&ServerInfo.ip, res->ai_addr, res->ai_addrlen);
683 ServerInfo.ip.ss.ss_family = res->ai_family;
684 ServerInfo.ip.ss_len = res->ai_addrlen;
685 irc_freeaddrinfo(res);
686
687 ServerInfo.specific_ipv4_vhost = 1;
688 }
689 }
690 };
691
692 serverinfo_vhost6: VHOST6 '=' QSTRING ';'
693 {
694 #ifdef IPV6
695 if (ypass == 2 && *yylval.string != '*')
696 {
697 struct addrinfo hints, *res;
698
699 memset(&hints, 0, sizeof(hints));
700
701 hints.ai_family = AF_UNSPEC;
702 hints.ai_socktype = SOCK_STREAM;
703 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
704
705 if (irc_getaddrinfo(yylval.string, NULL, &hints, &res))
706 ilog(L_ERROR, "Invalid netmask for server vhost6(%s)", yylval.string);
707 else
708 {
709 assert(res != NULL);
710
711 memcpy(&ServerInfo.ip6, res->ai_addr, res->ai_addrlen);
712 ServerInfo.ip6.ss.ss_family = res->ai_family;
713 ServerInfo.ip6.ss_len = res->ai_addrlen;
714 irc_freeaddrinfo(res);
715
716 ServerInfo.specific_ipv6_vhost = 1;
717 }
718 }
719 #endif
720 };
721
722 serverinfo_max_clients: T_MAX_CLIENTS '=' NUMBER ';'
723 {
724 if (ypass == 2)
725 {
726 recalc_fdlimit(NULL);
727
728 if ($3 < MAXCLIENTS_MIN)
729 {
730 char buf[IRCD_BUFSIZE];
731 ircsprintf(buf, "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
732 yyerror(buf);
733 }
734 else if ($3 > MAXCLIENTS_MAX)
735 {
736 char buf[IRCD_BUFSIZE];
737 ircsprintf(buf, "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
738 yyerror(buf);
739 }
740 else
741 ServerInfo.max_clients = $3;
742 }
743 };
744
745 serverinfo_hub: HUB '=' TBOOL ';'
746 {
747 if (ypass == 2)
748 {
749 if (yylval.number)
750 {
751 /* Don't become a hub if we have a lazylink active. */
752 if (!ServerInfo.hub && uplink && IsCapable(uplink, CAP_LL))
753 {
754 sendto_realops_flags(UMODE_ALL, L_ALL,
755 "Ignoring config file line hub=yes; "
756 "due to active LazyLink (%s)", uplink->name);
757 }
758 else
759 {
760 ServerInfo.hub = 1;
761 uplink = NULL;
762 delete_capability("HUB");
763 add_capability("HUB", CAP_HUB, 1);
764 }
765 }
766 else if (ServerInfo.hub)
767 {
768 dlink_node *ptr = NULL;
769
770 ServerInfo.hub = 0;
771 delete_capability("HUB");
772
773 /* Don't become a leaf if we have a lazylink active. */
774 DLINK_FOREACH(ptr, serv_list.head)
775 {
776 const struct Client *acptr = ptr->data;
777 if (MyConnect(acptr) && IsCapable(acptr, CAP_LL))
778 {
779 sendto_realops_flags(UMODE_ALL, L_ALL,
780 "Ignoring config file line hub=no; "
781 "due to active LazyLink (%s)",
782 acptr->name);
783 add_capability("HUB", CAP_HUB, 1);
784 ServerInfo.hub = 1;
785 break;
786 }
787 }
788 }
789 }
790 };
791
792 /***************************************************************************
793 * admin section
794 ***************************************************************************/
795 admin_entry: ADMIN '{' admin_items '}' ';' ;
796
797 admin_items: admin_items admin_item | admin_item;
798 admin_item: admin_name | admin_description |
799 admin_email | error ';' ;
800
801 admin_name: NAME '=' QSTRING ';'
802 {
803 if (ypass == 2)
804 {
805 MyFree(AdminInfo.name);
806 DupString(AdminInfo.name, yylval.string);
807 }
808 };
809
810 admin_email: EMAIL '=' QSTRING ';'
811 {
812 if (ypass == 2)
813 {
814 MyFree(AdminInfo.email);
815 DupString(AdminInfo.email, yylval.string);
816 }
817 };
818
819 admin_description: DESCRIPTION '=' QSTRING ';'
820 {
821 if (ypass == 2)
822 {
823 MyFree(AdminInfo.description);
824 DupString(AdminInfo.description, yylval.string);
825 }
826 };
827
828 /***************************************************************************
829 * section logging
830 ***************************************************************************/
831 /* XXX */
832 logging_entry: LOGGING '{' logging_items '}' ';' ;
833
834 logging_items: logging_items logging_item |
835 logging_item ;
836
837 logging_item: logging_path | logging_oper_log |
838 logging_log_level |
839 logging_use_logging | logging_fuserlog |
840 logging_foperlog | logging_fglinelog |
841 logging_fklinelog | logging_killlog |
842 logging_foperspylog | logging_ioerrlog |
843 logging_ffailed_operlog |
844 error ';' ;
845
846 logging_path: T_LOGPATH '=' QSTRING ';'
847 {
848 };
849
850 logging_oper_log: OPER_LOG '=' QSTRING ';'
851 {
852 };
853
854 logging_fuserlog: FUSERLOG '=' QSTRING ';'
855 {
856 if (ypass == 2)
857 strlcpy(ConfigLoggingEntry.userlog, yylval.string,
858 sizeof(ConfigLoggingEntry.userlog));
859 };
860
861 logging_ffailed_operlog: FFAILED_OPERLOG '=' QSTRING ';'
862 {
863 if (ypass == 2)
864 strlcpy(ConfigLoggingEntry.failed_operlog, yylval.string,
865 sizeof(ConfigLoggingEntry.failed_operlog));
866 };
867
868 logging_foperlog: FOPERLOG '=' QSTRING ';'
869 {
870 if (ypass == 2)
871 strlcpy(ConfigLoggingEntry.operlog, yylval.string,
872 sizeof(ConfigLoggingEntry.operlog));
873 };
874
875 logging_foperspylog: FOPERSPYLOG '=' QSTRING ';'
876 {
877 if (ypass == 2)
878 strlcpy(ConfigLoggingEntry.operspylog, yylval.string,
879 sizeof(ConfigLoggingEntry.operspylog));
880 };
881
882 logging_fglinelog: FGLINELOG '=' QSTRING ';'
883 {
884 if (ypass == 2)
885 strlcpy(ConfigLoggingEntry.glinelog, yylval.string,
886 sizeof(ConfigLoggingEntry.glinelog));
887 };
888
889 logging_fklinelog: FKLINELOG '=' QSTRING ';'
890 {
891 if (ypass == 2)
892 strlcpy(ConfigLoggingEntry.klinelog, yylval.string,
893 sizeof(ConfigLoggingEntry.klinelog));
894 };
895
896 logging_ioerrlog: FIOERRLOG '=' QSTRING ';'
897 {
898 if (ypass == 2)
899 strlcpy(ConfigLoggingEntry.ioerrlog, yylval.string,
900 sizeof(ConfigLoggingEntry.ioerrlog));
901 };
902
903 logging_killlog: FKILLLOG '=' QSTRING ';'
904 {
905 if (ypass == 2)
906 strlcpy(ConfigLoggingEntry.killlog, yylval.string,
907 sizeof(ConfigLoggingEntry.killlog));
908 };
909
910 logging_log_level: LOG_LEVEL '=' T_L_CRIT ';'
911 {
912 if (ypass == 2)
913 set_log_level(L_CRIT);
914 } | LOG_LEVEL '=' T_L_ERROR ';'
915 {
916 if (ypass == 2)
917 set_log_level(L_ERROR);
918 } | LOG_LEVEL '=' T_L_WARN ';'
919 {
920 if (ypass == 2)
921 set_log_level(L_WARN);
922 } | LOG_LEVEL '=' T_L_NOTICE ';'
923 {
924 if (ypass == 2)
925 set_log_level(L_NOTICE);
926 } | LOG_LEVEL '=' T_L_TRACE ';'
927 {
928 if (ypass == 2)
929 set_log_level(L_TRACE);
930 } | LOG_LEVEL '=' T_L_INFO ';'
931 {
932 if (ypass == 2)
933 set_log_level(L_INFO);
934 } | LOG_LEVEL '=' T_L_DEBUG ';'
935 {
936 if (ypass == 2)
937 set_log_level(L_DEBUG);
938 };
939
940 logging_use_logging: USE_LOGGING '=' TBOOL ';'
941 {
942 if (ypass == 2)
943 ConfigLoggingEntry.use_logging = yylval.number;
944 };
945
946 /***************************************************************************
947 * section oper
948 ***************************************************************************/
949 oper_entry: OPERATOR
950 {
951 if (ypass == 2)
952 {
953 yy_conf = make_conf_item(OPER_TYPE);
954 yy_aconf = map_to_conf(yy_conf);
955 SetConfEncrypted(yy_aconf); /* Yes, the default is encrypted */
956 }
957 else
958 {
959 MyFree(class_name);
960 class_name = NULL;
961 }
962 } oper_name_b '{' oper_items '}' ';'
963 {
964 if (ypass == 2)
965 {
966 struct CollectItem *yy_tmp;
967 dlink_node *ptr;
968 dlink_node *next_ptr;
969
970 conf_add_class_to_conf(yy_conf, class_name);
971
972 /* Now, make sure there is a copy of the "base" given oper
973 * block in each of the collected copies
974 */
975
976 DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
977 {
978 struct AccessItem *new_aconf;
979 struct ConfItem *new_conf;
980 yy_tmp = ptr->data;
981
982 new_conf = make_conf_item(OPER_TYPE);
983 new_aconf = (struct AccessItem *)map_to_conf(new_conf);
984
985 new_aconf->flags = yy_aconf->flags;
986
987 if (yy_conf->name != NULL)
988 DupString(new_conf->name, yy_conf->name);
989 if (yy_tmp->user != NULL)
990 DupString(new_aconf->user, yy_tmp->user);
991 else
992 DupString(new_aconf->user, "*");
993 if (yy_tmp->host != NULL)
994 DupString(new_aconf->host, yy_tmp->host);
995 else
996 DupString(new_aconf->host, "*");
997 conf_add_class_to_conf(new_conf, class_name);
998 if (yy_aconf->passwd != NULL)
999 DupString(new_aconf->passwd, yy_aconf->passwd);
1000
1001 new_aconf->port = yy_aconf->port;
1002 #ifdef HAVE_LIBCRYPTO
1003 if (yy_aconf->rsa_public_key_file != NULL)
1004 {
1005 BIO *file;
1006
1007 DupString(new_aconf->rsa_public_key_file,
1008 yy_aconf->rsa_public_key_file);
1009
1010 file = BIO_new_file(yy_aconf->rsa_public_key_file, "r");
1011 new_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file,
1012 NULL, 0, NULL);
1013 BIO_set_close(file, BIO_CLOSE);
1014 BIO_free(file);
1015 }
1016 #endif
1017
1018 #ifdef HAVE_LIBCRYPTO
1019 if (yy_tmp->name && (yy_tmp->passwd || yy_aconf->rsa_public_key)
1020 && yy_tmp->host)
1021 #else
1022 if (yy_tmp->name && yy_tmp->passwd && yy_tmp->host)
1023 #endif
1024 {
1025 conf_add_class_to_conf(new_conf, class_name);
1026 if (yy_tmp->name != NULL)
1027 DupString(new_conf->name, yy_tmp->name);
1028 }
1029
1030 dlinkDelete(&yy_tmp->node, &col_conf_list);
1031 free_collect_item(yy_tmp);
1032 }
1033
1034 yy_conf = NULL;
1035 yy_aconf = NULL;
1036
1037
1038 MyFree(class_name);
1039 class_name = NULL;
1040 }
1041 };
1042
1043 oper_name_b: | oper_name_t;
1044 oper_items: oper_items oper_item | oper_item;
1045 oper_item: oper_name | oper_user | oper_password | oper_hidden_admin |
1046 oper_hidden_oper | oper_umodes |
1047 oper_class | oper_global_kill | oper_remote |
1048 oper_kline | oper_xline | oper_unkline |
1049 oper_gline | oper_nick_changes | oper_remoteban |
1050 oper_die | oper_rehash | oper_admin | oper_operwall |
1051 oper_encrypted | oper_rsa_public_key_file |
1052 oper_flags | error ';' ;
1053
1054 oper_name: NAME '=' QSTRING ';'
1055 {
1056 if (ypass == 2)
1057 {
1058 if (strlen(yylval.string) > OPERNICKLEN)
1059 yylval.string[OPERNICKLEN] = '\0';
1060
1061 MyFree(yy_conf->name);
1062 DupString(yy_conf->name, yylval.string);
1063 }
1064 };
1065
1066 oper_name_t: QSTRING
1067 {
1068 if (ypass == 2)
1069 {
1070 if (strlen(yylval.string) > OPERNICKLEN)
1071 yylval.string[OPERNICKLEN] = '\0';
1072
1073 MyFree(yy_conf->name);
1074 DupString(yy_conf->name, yylval.string);
1075 }
1076 };
1077
1078 oper_user: USER '=' QSTRING ';'
1079 {
1080 if (ypass == 2)
1081 {
1082 struct CollectItem *yy_tmp;
1083
1084 if (yy_aconf->user == NULL)
1085 {
1086 split_nuh(yylval.string, NULL, &yy_aconf->user, &yy_aconf->host);
1087 }
1088 else
1089 {
1090 yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
1091 split_nuh(yylval.string, NULL, &yy_tmp->user, &yy_tmp->host);
1092 dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
1093 }
1094 }
1095 };
1096
1097 oper_password: PASSWORD '=' QSTRING ';'
1098 {
1099 if (ypass == 2)
1100 {
1101 if (yy_aconf->passwd != NULL)
1102 memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
1103
1104 MyFree(yy_aconf->passwd);
1105 DupString(yy_aconf->passwd, yylval.string);
1106 }
1107 };
1108
1109 oper_encrypted: ENCRYPTED '=' TBOOL ';'
1110 {
1111 if (ypass == 2)
1112 {
1113 if (yylval.number)
1114 SetConfEncrypted(yy_aconf);
1115 else
1116 ClearConfEncrypted(yy_aconf);
1117 }
1118 };
1119
1120 oper_rsa_public_key_file: RSA_PUBLIC_KEY_FILE '=' QSTRING ';'
1121 {
1122 #ifdef HAVE_LIBCRYPTO
1123 if (ypass == 2)
1124 {
1125 BIO *file;
1126
1127 if (yy_aconf->rsa_public_key != NULL)
1128 {
1129 RSA_free(yy_aconf->rsa_public_key);
1130 yy_aconf->rsa_public_key = NULL;
1131 }
1132
1133 if (yy_aconf->rsa_public_key_file != NULL)
1134 {
1135 MyFree(yy_aconf->rsa_public_key_file);
1136 yy_aconf->rsa_public_key_file = NULL;
1137 }
1138
1139 DupString(yy_aconf->rsa_public_key_file, yylval.string);
1140 file = BIO_new_file(yylval.string, "r");
1141
1142 if (file == NULL)
1143 {
1144 yyerror("Ignoring rsa_public_key_file -- file doesn't exist");
1145 break;
1146 }
1147
1148 yy_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
1149
1150 if (yy_aconf->rsa_public_key == NULL)
1151 {
1152 yyerror("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
1153 break;
1154 }
1155
1156 BIO_set_close(file, BIO_CLOSE);
1157 BIO_free(file);
1158 }
1159 #endif /* HAVE_LIBCRYPTO */
1160 };
1161
1162 oper_class: CLASS '=' QSTRING ';'
1163 {
1164 if (ypass == 2)
1165 {
1166 MyFree(class_name);
1167 DupString(class_name, yylval.string);
1168 }
1169 };
1170
1171 oper_umodes: T_UMODES
1172 {
1173 if (ypass == 2)
1174 yy_aconf->modes = 0;
1175 } '=' oper_umodes_items ';' ;
1176
1177 oper_umodes_items: oper_umodes_items ',' oper_umodes_item | oper_umodes_item;
1178 oper_umodes_item: T_BOTS
1179 {
1180 if (ypass == 2)
1181 yy_aconf->modes |= UMODE_BOTS;
1182 } | T_CCONN
1183 {
1184 if (ypass == 2)
1185 yy_aconf->modes |= UMODE_CCONN;
1186 } | T_DEAF
1187 {
1188 if (ypass == 2)
1189 yy_aconf->modes |= UMODE_DEAF;
1190 } | T_DEBUG
1191 {
1192 if (ypass == 2)
1193 yy_aconf->modes |= UMODE_DEBUG;
1194 } | T_FULL
1195 {
1196 if (ypass == 2)
1197 yy_aconf->modes |= UMODE_FULL;
1198 } | T_SKILL
1199 {
1200 if (ypass == 2)
1201 yy_aconf->modes |= UMODE_SKILL;
1202 } | T_NCHANGE
1203 {
1204 if (ypass == 2)
1205 yy_aconf->modes |= UMODE_NCHANGE;
1206 } | T_REJ
1207 {
1208 if (ypass == 2)
1209 yy_aconf->modes |= UMODE_REJ;
1210 } | T_UNAUTH
1211 {
1212 if (ypass == 2)
1213 yy_aconf->modes |= UMODE_UNAUTH;
1214 } | T_SPY
1215 {
1216 if (ypass == 2)
1217 yy_aconf->modes |= UMODE_SPY;
1218 } | T_EXTERNAL
1219 {
1220 if (ypass == 2)
1221 yy_aconf->modes |= UMODE_EXTERNAL;
1222 } | T_OPERWALL
1223 {
1224 if (ypass == 2)
1225 yy_aconf->modes |= UMODE_OPERWALL;
1226 } | T_SERVNOTICE
1227 {
1228 if (ypass == 2)
1229 yy_aconf->modes |= UMODE_SERVNOTICE;
1230 } | T_INVISIBLE
1231 {
1232 if (ypass == 2)
1233 yy_aconf->modes |= UMODE_INVISIBLE;
1234 } | T_WALLOP
1235 {
1236 if (ypass == 2)
1237 yy_aconf->modes |= UMODE_WALLOP;
1238 } | T_SOFTCALLERID
1239 {
1240 if (ypass == 2)
1241 yy_aconf->modes |= UMODE_SOFTCALLERID;
1242 } | T_CALLERID
1243 {
1244 if (ypass == 2)
1245 yy_aconf->modes |= UMODE_CALLERID;
1246 } | T_LOCOPS
1247 {
1248 if (ypass == 2)
1249 yy_aconf->modes |= UMODE_LOCOPS;
1250 };
1251
1252 oper_global_kill: GLOBAL_KILL '=' TBOOL ';'
1253 {
1254 if (ypass == 2)
1255 {
1256 if (yylval.number)
1257 yy_aconf->port |= OPER_FLAG_GLOBAL_KILL;
1258 else
1259 yy_aconf->port &= ~OPER_FLAG_GLOBAL_KILL;
1260 }
1261 };
1262
1263 oper_remote: REMOTE '=' TBOOL ';'
1264 {
1265 if (ypass == 2)
1266 {
1267 if (yylval.number)
1268 yy_aconf->port |= OPER_FLAG_REMOTE;
1269 else
1270 yy_aconf->port &= ~OPER_FLAG_REMOTE;
1271 }
1272 };
1273
1274 oper_remoteban: REMOTEBAN '=' TBOOL ';'
1275 {
1276 if (ypass == 2)
1277 {
1278 if (yylval.number)
1279 yy_aconf->port |= OPER_FLAG_REMOTEBAN;
1280 else
1281 yy_aconf->port &= ~OPER_FLAG_REMOTEBAN;
1282 }
1283 };
1284
1285 oper_kline: KLINE '=' TBOOL ';'
1286 {
1287 if (ypass == 2)
1288 {
1289 if (yylval.number)
1290 yy_aconf->port |= OPER_FLAG_K;
1291 else
1292 yy_aconf->port &= ~OPER_FLAG_K;
1293 }
1294 };
1295
1296 oper_xline: XLINE '=' TBOOL ';'
1297 {
1298 if (ypass == 2)
1299 {
1300 if (yylval.number)
1301 yy_aconf->port |= OPER_FLAG_X;
1302 else
1303 yy_aconf->port &= ~OPER_FLAG_X;
1304 }
1305 };
1306
1307 oper_unkline: UNKLINE '=' TBOOL ';'
1308 {
1309 if (ypass == 2)
1310 {
1311 if (yylval.number)
1312 yy_aconf->port |= OPER_FLAG_UNKLINE;
1313 else
1314 yy_aconf->port &= ~OPER_FLAG_UNKLINE;
1315 }
1316 };
1317
1318 oper_gline: GLINE '=' TBOOL ';'
1319 {
1320 if (ypass == 2)
1321 {
1322 if (yylval.number)
1323 yy_aconf->port |= OPER_FLAG_GLINE;
1324 else
1325 yy_aconf->port &= ~OPER_FLAG_GLINE;
1326 }
1327 };
1328
1329 oper_nick_changes: NICK_CHANGES '=' TBOOL ';'
1330 {
1331 if (ypass == 2)
1332 {
1333 if (yylval.number)
1334 yy_aconf->port |= OPER_FLAG_N;
1335 else
1336 yy_aconf->port &= ~OPER_FLAG_N;
1337 }
1338 };
1339
1340 oper_die: DIE '=' TBOOL ';'
1341 {
1342 if (ypass == 2)
1343 {
1344 if (yylval.number)
1345 yy_aconf->port |= OPER_FLAG_DIE;
1346 else
1347 yy_aconf->port &= ~OPER_FLAG_DIE;
1348 }
1349 };
1350
1351 oper_rehash: REHASH '=' TBOOL ';'
1352 {
1353 if (ypass == 2)
1354 {
1355 if (yylval.number)
1356 yy_aconf->port |= OPER_FLAG_REHASH;
1357 else
1358 yy_aconf->port &= ~OPER_FLAG_REHASH;
1359 }
1360 };
1361
1362 oper_admin: ADMIN '=' TBOOL ';'
1363 {
1364 if (ypass == 2)
1365 {
1366 if (yylval.number)
1367 yy_aconf->port |= OPER_FLAG_ADMIN;
1368 else
1369 yy_aconf->port &= ~OPER_FLAG_ADMIN;
1370 }
1371 };
1372
1373 oper_hidden_admin: HIDDEN_ADMIN '=' TBOOL ';'
1374 {
1375 if (ypass == 2)
1376 {
1377 if (yylval.number)
1378 yy_aconf->port |= OPER_FLAG_HIDDEN_ADMIN;
1379 else
1380 yy_aconf->port &= ~OPER_FLAG_HIDDEN_ADMIN;
1381 }
1382 };
1383
1384 oper_hidden_oper: HIDDEN_OPER '=' TBOOL ';'
1385 {
1386 if (ypass == 2)
1387 {
1388 if (yylval.number)
1389 yy_aconf->port |= OPER_FLAG_HIDDEN_OPER;
1390 else
1391 yy_aconf->port &= ~OPER_FLAG_HIDDEN_OPER;
1392 }
1393 };
1394
1395 oper_operwall: T_OPERWALL '=' TBOOL ';'
1396 {
1397 if (ypass == 2)
1398 {
1399 if (yylval.number)
1400 yy_aconf->port |= OPER_FLAG_OPERWALL;
1401 else
1402 yy_aconf->port &= ~OPER_FLAG_OPERWALL;
1403 }
1404 };
1405
1406 oper_flags: IRCD_FLAGS
1407 {
1408 } '=' oper_flags_items ';';
1409
1410 oper_flags_items: oper_flags_items ',' oper_flags_item | oper_flags_item;
1411 oper_flags_item: NOT { not_atom = 1; } oper_flags_item_atom
1412 | { not_atom = 0; } oper_flags_item_atom;
1413
1414 oper_flags_item_atom: GLOBAL_KILL
1415 {
1416 if (ypass == 2)
1417 {
1418 if (not_atom)yy_aconf->port &= ~OPER_FLAG_GLOBAL_KILL;
1419 else yy_aconf->port |= OPER_FLAG_GLOBAL_KILL;
1420 }
1421 } | REMOTE
1422 {
1423 if (ypass == 2)
1424 {
1425 if (not_atom) yy_aconf->port &= ~OPER_FLAG_REMOTE;
1426 else yy_aconf->port |= OPER_FLAG_REMOTE;
1427 }
1428 } | KLINE
1429 {
1430 if (ypass == 2)
1431 {
1432 if (not_atom) yy_aconf->port &= ~OPER_FLAG_K;
1433 else yy_aconf->port |= OPER_FLAG_K;
1434 }
1435 } | UNKLINE
1436 {
1437 if (ypass == 2)
1438 {
1439 if (not_atom) yy_aconf->port &= ~OPER_FLAG_UNKLINE;
1440 else yy_aconf->port |= OPER_FLAG_UNKLINE;
1441 }
1442 } | XLINE
1443 {
1444 if (ypass == 2)
1445 {
1446 if (not_atom) yy_aconf->port &= ~OPER_FLAG_X;
1447 else yy_aconf->port |= OPER_FLAG_X;
1448 }
1449 } | GLINE
1450 {
1451 if (ypass == 2)
1452 {
1453 if (not_atom) yy_aconf->port &= ~OPER_FLAG_GLINE;
1454 else yy_aconf->port |= OPER_FLAG_GLINE;
1455 }
1456 } | DIE
1457 {
1458 if (ypass == 2)
1459 {
1460 if (not_atom) yy_aconf->port &= ~OPER_FLAG_DIE;
1461 else yy_aconf->port |= OPER_FLAG_DIE;
1462 }
1463 } | REHASH
1464 {
1465 if (ypass == 2)
1466 {
1467 if (not_atom) yy_aconf->port &= ~OPER_FLAG_REHASH;
1468 else yy_aconf->port |= OPER_FLAG_REHASH;
1469 }
1470 } | ADMIN
1471 {
1472 if (ypass == 2)
1473 {
1474 if (not_atom) yy_aconf->port &= ~OPER_FLAG_ADMIN;
1475 else yy_aconf->port |= OPER_FLAG_ADMIN;
1476 }
1477 } | HIDDEN_ADMIN
1478 {
1479 if (ypass == 2)
1480 {
1481 if (not_atom) yy_aconf->port &= ~OPER_FLAG_HIDDEN_ADMIN;
1482 else yy_aconf->port |= OPER_FLAG_HIDDEN_ADMIN;
1483 }
1484 } | NICK_CHANGES
1485 {
1486 if (ypass == 2)
1487 {
1488 if (not_atom) yy_aconf->port &= ~OPER_FLAG_N;
1489 else yy_aconf->port |= OPER_FLAG_N;
1490 }
1491 } | T_OPERWALL
1492 {
1493 if (ypass == 2)
1494 {
1495 if (not_atom) yy_aconf->port &= ~OPER_FLAG_OPERWALL;
1496 else yy_aconf->port |= OPER_FLAG_OPERWALL;
1497 }
1498 } | OPER_SPY_T
1499 {
1500 if (ypass == 2)
1501 {
1502 if (not_atom) yy_aconf->port &= ~OPER_FLAG_OPER_SPY;
1503 else yy_aconf->port |= OPER_FLAG_OPER_SPY;
1504 }
1505 } | HIDDEN_OPER
1506 {
1507 if (ypass == 2)
1508 {
1509 if (not_atom) yy_aconf->port &= ~OPER_FLAG_HIDDEN_OPER;
1510 else yy_aconf->port |= OPER_FLAG_HIDDEN_OPER;
1511 }
1512 } | REMOTEBAN
1513 {
1514 if (ypass == 2)
1515 {
1516 if (not_atom) yy_aconf->port &= ~OPER_FLAG_REMOTEBAN;
1517 else yy_aconf->port |= OPER_FLAG_REMOTEBAN;
1518 }
1519 } | ENCRYPTED
1520 {
1521 if (ypass == 2)
1522 {
1523 if (not_atom) ClearConfEncrypted(yy_aconf);
1524 else SetConfEncrypted(yy_aconf);
1525 }
1526 };
1527
1528
1529 /***************************************************************************
1530 * section class
1531 ***************************************************************************/
1532 class_entry: CLASS
1533 {
1534 if (ypass == 1)
1535 {
1536 yy_conf = make_conf_item(CLASS_TYPE);
1537 yy_class = (struct ClassItem *)map_to_conf(yy_conf);
1538 }
1539 } class_name_b '{' class_items '}' ';'
1540 {
1541 if (ypass == 1)
1542 {
1543 struct ConfItem *cconf;
1544 struct ClassItem *class = NULL;
1545
1546 if (yy_class_name == NULL)
1547 {
1548 delete_conf_item(yy_conf);
1549 }
1550 else
1551 {
1552 cconf = find_exact_name_conf(CLASS_TYPE, yy_class_name, NULL, NULL);
1553
1554 if (cconf != NULL) /* The class existed already */
1555 {
1556 rebuild_cidr_class(cconf, yy_class);
1557 class = (struct ClassItem *) map_to_conf(cconf);
1558 *class = *yy_class;
1559 delete_conf_item(yy_conf);
1560
1561 MyFree(cconf->name); /* Allows case change of class name */
1562 cconf->name = yy_class_name;
1563 }
1564 else /* Brand new class */
1565 {
1566 MyFree(yy_conf->name); /* just in case it was allocated */
1567 yy_conf->name = yy_class_name;
1568 }
1569 }
1570 yy_class_name = NULL;
1571 }
1572 };
1573
1574 class_name_b: | class_name_t;
1575
1576 class_items: class_items class_item | class_item;
1577 class_item: class_name |
1578 class_cidr_bitlen_ipv4 | class_cidr_bitlen_ipv6 |
1579 class_ping_time |
1580 class_ping_warning |
1581 class_number_per_cidr |
1582 class_number_per_ip |
1583 class_connectfreq |
1584 class_max_number |
1585 class_max_global |
1586 class_max_local |
1587 class_max_ident |
1588 class_sendq |
1589 error ';' ;
1590
1591 class_name: NAME '=' QSTRING ';'
1592 {
1593 if (ypass == 1)
1594 {
1595 MyFree(yy_class_name);
1596 DupString(yy_class_name, yylval.string);
1597 }
1598 };
1599
1600 class_name_t: QSTRING
1601 {
1602 if (ypass == 1)
1603 {
1604 MyFree(yy_class_name);
1605 DupString(yy_class_name, yylval.string);
1606 }
1607 };
1608
1609 class_ping_time: PING_TIME '=' timespec ';'
1610 {
1611 if (ypass == 1)
1612 PingFreq(yy_class) = $3;
1613 };
1614
1615 class_ping_warning: PING_WARNING '=' timespec ';'
1616 {
1617 if (ypass == 1)
1618 PingWarning(yy_class) = $3;
1619 };
1620
1621 class_number_per_ip: NUMBER_PER_IP '=' NUMBER ';'
1622 {
1623 if (ypass == 1)
1624 MaxPerIp(yy_class) = $3;
1625 };
1626
1627 class_connectfreq: CONNECTFREQ '=' timespec ';'
1628 {
1629 if (ypass == 1)
1630 ConFreq(yy_class) = $3;
1631 };
1632
1633 class_max_number: MAX_NUMBER '=' NUMBER ';'
1634 {
1635 if (ypass == 1)
1636 MaxTotal(yy_class) = $3;
1637 };
1638
1639 class_max_global: MAX_GLOBAL '=' NUMBER ';'
1640 {
1641 if (ypass == 1)
1642 MaxGlobal(yy_class) = $3;
1643 };
1644
1645 class_max_local: MAX_LOCAL '=' NUMBER ';'
1646 {
1647 if (ypass == 1)
1648 MaxLocal(yy_class) = $3;
1649 };
1650
1651 class_max_ident: MAX_IDENT '=' NUMBER ';'
1652 {
1653 if (ypass == 1)
1654 MaxIdent(yy_class) = $3;
1655 };
1656
1657 class_sendq: SENDQ '=' sizespec ';'
1658 {
1659 if (ypass == 1)
1660 MaxSendq(yy_class) = $3;
1661 };
1662
1663 class_cidr_bitlen_ipv4: CIDR_BITLEN_IPV4 '=' NUMBER ';'
1664 {
1665 if (ypass == 1)
1666 CidrBitlenIPV4(yy_class) = $3;
1667 };
1668
1669 class_cidr_bitlen_ipv6: CIDR_BITLEN_IPV6 '=' NUMBER ';'
1670 {
1671 if (ypass == 1)
1672 CidrBitlenIPV6(yy_class) = $3;
1673 };
1674
1675 class_number_per_cidr: NUMBER_PER_CIDR '=' NUMBER ';'
1676 {
1677 if (ypass == 1)
1678 NumberPerCidr(yy_class) = $3;
1679 };
1680
1681 /***************************************************************************
1682 * section listen
1683 ***************************************************************************/
1684 listen_entry: LISTEN
1685 {
1686 if (ypass == 2)
1687 {
1688 listener_address = NULL;
1689 listener_flags = 0;
1690 }
1691 } '{' listen_items '}' ';'
1692 {
1693 if (ypass == 2)
1694 {
1695 MyFree(listener_address);
1696 listener_address = NULL;
1697 }
1698 };
1699
1700 listen_flags: IRCD_FLAGS
1701 {
1702 } '=' listen_flags_items ';';
1703
1704 listen_flags_items: listen_flags_items ',' listen_flags_item | listen_flags_item;
1705 listen_flags_item: T_SSL
1706 {
1707 if (ypass == 2)
1708 listener_flags |= LISTENER_SSL;
1709 } | HIDDEN
1710 {
1711 if (ypass == 2)
1712 listener_flags |= LISTENER_HIDDEN;
1713 };
1714
1715 listen_items: listen_items listen_item | listen_item;
1716 listen_item: listen_port | listen_flags | listen_address | listen_host | error ';' ;
1717
1718 listen_port: PORT '=' port_items ';' ;
1719
1720 port_items: port_items ',' port_item | port_item;
1721
1722 port_item: NUMBER
1723 {
1724 if (ypass == 2)
1725 {
1726 if ((listener_flags & LISTENER_SSL))
1727 #ifdef HAVE_LIBCRYPTO
1728 if (!ServerInfo.ctx)
1729 #endif
1730 {
1731 yyerror("SSL not available - port closed");
1732 break;
1733 }
1734 add_listener($1, listener_address, listener_flags);
1735 listener_flags = 0;
1736 }
1737 } | NUMBER TWODOTS NUMBER
1738 {
1739 if (ypass == 2)
1740 {
1741 int i;
1742
1743 if ((listener_flags & LISTENER_SSL))
1744 #ifdef HAVE_LIBCRYPTO
1745 if (!ServerInfo.ctx)
1746 #endif
1747 {
1748 yyerror("SSL not available - port closed");
1749 break;
1750 }
1751
1752 for (i = $1; i <= $3; ++i)
1753 add_listener(i, listener_address, listener_flags);
1754
1755 listener_flags = 0;
1756 }
1757 };
1758
1759 listen_address: IP '=' QSTRING ';'
1760 {
1761 if (ypass == 2)
1762 {
1763 MyFree(listener_address);
1764 DupString(listener_address, yylval.string);
1765 }
1766 };
1767
1768 listen_host: HOST '=' QSTRING ';'
1769 {
1770 if (ypass == 2)
1771 {
1772 MyFree(listener_address);
1773 DupString(listener_address, yylval.string);
1774 }
1775 };
1776
1777 /***************************************************************************
1778 * section auth
1779 ***************************************************************************/
1780 auth_entry: IRCD_AUTH
1781 {
1782 if (ypass == 2)
1783 {
1784 yy_conf = make_conf_item(CLIENT_TYPE);
1785 yy_aconf = map_to_conf(yy_conf);
1786 }
1787 else
1788 {
1789 MyFree(class_name);
1790 class_name = NULL;
1791 }
1792 } '{' auth_items '}' ';'
1793 {
1794 if (ypass == 2)
1795 {
1796 struct CollectItem *yy_tmp = NULL;
1797 dlink_node *ptr = NULL, *next_ptr = NULL;
1798
1799 if (yy_aconf->user && yy_aconf->host)
1800 {
1801 conf_add_class_to_conf(yy_conf, class_name);
1802 add_conf_by_address(CONF_CLIENT, yy_aconf);
1803 }
1804 else
1805 delete_conf_item(yy_conf);
1806
1807 /* copy over settings from first struct */
1808 DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
1809 {
1810 struct AccessItem *new_aconf;
1811 struct ConfItem *new_conf;
1812
1813 new_conf = make_conf_item(CLIENT_TYPE);
1814 new_aconf = map_to_conf(new_conf);
1815
1816 yy_tmp = ptr->data;
1817
1818 assert(yy_tmp->user && yy_tmp->host);
1819
1820 if (yy_aconf->passwd != NULL)
1821 DupString(new_aconf->passwd, yy_aconf->passwd);
1822 if (yy_conf->name != NULL)
1823 DupString(new_conf->name, yy_conf->name);
1824 if (yy_aconf->passwd != NULL)
1825 DupString(new_aconf->passwd, yy_aconf->passwd);
1826
1827 new_aconf->flags = yy_aconf->flags;
1828 new_aconf->port = yy_aconf->port;
1829
1830 DupString(new_aconf->user, yy_tmp->user);
1831 collapse(new_aconf->user);
1832
1833 DupString(new_aconf->host, yy_tmp->host);
1834 collapse(new_aconf->host);
1835
1836 conf_add_class_to_conf(new_conf, class_name);
1837 add_conf_by_address(CONF_CLIENT, new_aconf);
1838 dlinkDelete(&yy_tmp->node, &col_conf_list);
1839 free_collect_item(yy_tmp);
1840 }
1841
1842 MyFree(class_name);
1843 class_name = NULL;
1844 yy_conf = NULL;
1845 yy_aconf = NULL;
1846 }
1847 };
1848
1849 auth_items: auth_items auth_item | auth_item;
1850 auth_item: auth_user | auth_passwd | auth_class | auth_flags |
1851 auth_kline_exempt | auth_need_ident |
1852 auth_exceed_limit | auth_no_tilde | auth_gline_exempt |
1853 auth_spoof | auth_spoof_notice |
1854 auth_redir_serv | auth_redir_port | auth_can_flood |
1855 auth_need_password | auth_encrypted | error ';' ;
1856
1857 auth_user: USER '=' QSTRING ';'
1858 {
1859 if (ypass == 2)
1860 {
1861 struct CollectItem *yy_tmp;
1862
1863 if (yy_aconf->user == NULL)
1864 split_nuh(yylval.string, NULL, &yy_aconf->user, &yy_aconf->host);
1865 else
1866 {
1867 yy_tmp = MyMalloc(sizeof(struct CollectItem));
1868 split_nuh(yylval.string, NULL, &yy_tmp->user, &yy_tmp->host);
1869 dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
1870 }
1871 }
1872 };
1873
1874 /* XXX - IP/IPV6 tags don't exist anymore - put IP/IPV6 into user. */
1875
1876 auth_passwd: PASSWORD '=' QSTRING ';'
1877 {
1878 if (ypass == 2)
1879 {
1880 /* be paranoid */
1881 if (yy_aconf->passwd != NULL)
1882 memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
1883
1884 MyFree(yy_aconf->passwd);
1885 DupString(yy_aconf->passwd, yylval.string);
1886 }
1887 };
1888
1889 auth_spoof_notice: SPOOF_NOTICE '=' TBOOL ';'
1890 {
1891 if (ypass == 2)
1892 {
1893 if (yylval.number)
1894 yy_aconf->flags |= CONF_FLAGS_SPOOF_NOTICE;
1895 else
1896 yy_aconf->flags &= ~CONF_FLAGS_SPOOF_NOTICE;
1897 }
1898 };
1899
1900 auth_class: CLASS '=' QSTRING ';'
1901 {
1902 if (ypass == 2)
1903 {
1904 MyFree(class_name);
1905 DupString(class_name, yylval.string);
1906 }
1907 };
1908
1909 auth_encrypted: ENCRYPTED '=' TBOOL ';'
1910 {
1911 if (ypass == 2)
1912 {
1913 if (yylval.number)
1914 SetConfEncrypted(yy_aconf);
1915 else
1916 ClearConfEncrypted(yy_aconf);
1917 }
1918 };
1919
1920 auth_flags: IRCD_FLAGS
1921 {
1922 } '=' auth_flags_items ';';
1923
1924 auth_flags_items: auth_flags_items ',' auth_flags_item | auth_flags_item;
1925 auth_flags_item: NOT { not_atom = 1; } auth_flags_item_atom
1926 | { not_atom = 0; } auth_flags_item_atom;
1927
1928 auth_flags_item_atom: SPOOF_NOTICE
1929 {
1930 if (ypass == 2)
1931 {
1932 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_SPOOF_NOTICE;
1933 else yy_aconf->flags |= CONF_FLAGS_SPOOF_NOTICE;
1934 }
1935
1936 } | EXCEED_LIMIT
1937 {
1938 if (ypass == 2)
1939 {
1940 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NOLIMIT;
1941 else yy_aconf->flags |= CONF_FLAGS_NOLIMIT;
1942 }
1943 } | KLINE_EXEMPT
1944 {
1945 if (ypass == 2)
1946 {
1947 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_EXEMPTKLINE;
1948 else yy_aconf->flags |= CONF_FLAGS_EXEMPTKLINE;
1949 }
1950 } | NEED_IDENT
1951 {
1952 if (ypass == 2)
1953 {
1954 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NEED_IDENTD;
1955 else yy_aconf->flags |= CONF_FLAGS_NEED_IDENTD;
1956 }
1957 } | CAN_FLOOD
1958 {
1959 if (ypass == 2)
1960 {
1961 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_CAN_FLOOD;
1962 else yy_aconf->flags |= CONF_FLAGS_CAN_FLOOD;
1963 }
1964 } | CAN_IDLE
1965 {
1966 if (ypass == 2)
1967 {
1968 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_IDLE_LINED;
1969 else yy_aconf->flags |= CONF_FLAGS_IDLE_LINED;
1970 }
1971 } | NO_TILDE
1972 {
1973 if (ypass == 2)
1974 {
1975 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NO_TILDE;
1976 else yy_aconf->flags |= CONF_FLAGS_NO_TILDE;
1977 }
1978 } | GLINE_EXEMPT
1979 {
1980 if (ypass == 2)
1981 {
1982 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_EXEMPTGLINE;
1983 else yy_aconf->flags |= CONF_FLAGS_EXEMPTGLINE;
1984 }
1985 } | RESV_EXEMPT
1986 {
1987 if (ypass == 2)
1988 {
1989 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_EXEMPTRESV;
1990 else yy_aconf->flags |= CONF_FLAGS_EXEMPTRESV;
1991 }
1992 } | NEED_PASSWORD
1993 {
1994 if (ypass == 2)
1995 {
1996 if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NEED_PASSWORD;
1997 else yy_aconf->flags |= CONF_FLAGS_NEED_PASSWORD;
1998 }
1999 };
2000
2001 auth_kline_exempt: KLINE_EXEMPT '=' TBOOL ';'
2002 {
2003 if (ypass == 2)
2004 {
2005 if (yylval.number)
2006 yy_aconf->flags |= CONF_FLAGS_EXEMPTKLINE;
2007 else
2008 yy_aconf->flags &= ~CONF_FLAGS_EXEMPTKLINE;
2009 }
2010 };
2011
2012 auth_need_ident: NEED_IDENT '=' TBOOL ';'
2013 {
2014 if (ypass == 2)
2015 {
2016 if (yylval.number)
2017 yy_aconf->flags |= CONF_FLAGS_NEED_IDENTD;
2018 else
2019 yy_aconf->flags &= ~CONF_FLAGS_NEED_IDENTD;
2020 }
2021 };
2022
2023 auth_exceed_limit: EXCEED_LIMIT '=' TBOOL ';'
2024 {
2025 if (ypass == 2)
2026 {
2027 if (yylval.number)
2028 yy_aconf->flags |= CONF_FLAGS_NOLIMIT;
2029 else
2030 yy_aconf->flags &= ~CONF_FLAGS_NOLIMIT;
2031 }
2032 };
2033
2034 auth_can_flood: CAN_FLOOD '=' TBOOL ';'
2035 {
2036 if (ypass == 2)
2037 {
2038 if (yylval.number)
2039 yy_aconf->flags |= CONF_FLAGS_CAN_FLOOD;
2040 else
2041 yy_aconf->flags &= ~CONF_FLAGS_CAN_FLOOD;
2042 }
2043 };
2044
2045 auth_no_tilde: NO_TILDE '=' TBOOL ';'
2046 {
2047 if (ypass == 2)
2048 {
2049 if (yylval.number)
2050 yy_aconf->flags |= CONF_FLAGS_NO_TILDE;
2051 else
2052 yy_aconf->flags &= ~CONF_FLAGS_NO_TILDE;
2053 }
2054 };
2055
2056 auth_gline_exempt: GLINE_EXEMPT '=' TBOOL ';'
2057 {
2058 if (ypass == 2)
2059 {
2060 if (yylval.number)
2061 yy_aconf->flags |= CONF_FLAGS_EXEMPTGLINE;
2062 else
2063 yy_aconf->flags &= ~CONF_FLAGS_EXEMPTGLINE;
2064 }
2065 };
2066
2067 /* XXX - need check for illegal hostnames here */
2068 auth_spoof: SPOOF '=' QSTRING ';'
2069 {
2070 if (ypass == 2)
2071 {
2072 MyFree(yy_conf->name);
2073
2074 if (strlen(yylval.string) < HOSTLEN)
2075 {
2076 DupString(yy_conf->name, yylval.string);
2077 yy_aconf->flags |= CONF_FLAGS_SPOOF_IP;
2078 }
2079 else
2080 {
2081 ilog(L_ERROR, "Spoofs must be less than %d..ignoring it", HOSTLEN);
2082 yy_conf->name = NULL;
2083 }
2084 }
2085 };
2086
2087 auth_redir_serv: REDIRSERV '=' QSTRING ';'
2088 {
2089 if (ypass == 2)
2090 {
2091 yy_aconf->flags |= CONF_FLAGS_REDIR;
2092 MyFree(yy_conf->name);
2093 DupString(yy_conf->name, yylval.string);
2094 }
2095 };
2096
2097 auth_redir_port: REDIRPORT '=' NUMBER ';'
2098 {
2099 if (ypass == 2)
2100 {
2101 yy_aconf->flags |= CONF_FLAGS_REDIR;
2102 yy_aconf->port = $3;
2103 }
2104 };
2105
2106 auth_need_password: NEED_PASSWORD '=' TBOOL ';'
2107 {
2108 if (ypass == 2)
2109 {
2110 if (yylval.number)
2111 yy_aconf->flags |= CONF_FLAGS_NEED_PASSWORD;
2112 else
2113 yy_aconf->flags &= ~CONF_FLAGS_NEED_PASSWORD;
2114 }
2115 };
2116
2117
2118 /***************************************************************************
2119 * section resv
2120 ***************************************************************************/
2121 resv_entry: RESV
2122 {
2123 if (ypass == 2)
2124 {
2125 MyFree(resv_reason);
2126 resv_reason = NULL;
2127 }
2128 } '{' resv_items '}' ';'
2129 {
2130 if (ypass == 2)
2131 {
2132 MyFree(resv_reason);
2133 resv_reason = NULL;
2134 }
2135 };
2136
2137 resv_items: resv_items resv_item | resv_item;
2138 resv_item: resv_creason | resv_channel | resv_nick | error ';' ;
2139
2140 resv_creason: REASON '=' QSTRING ';'
2141 {
2142 if (ypass == 2)
2143 {
2144 MyFree(resv_reason);
2145 DupString(resv_reason, yylval.string);
2146 }
2147 };
2148
2149 resv_channel: CHANNEL '=' QSTRING ';'
2150 {
2151 if (ypass == 2)
2152 {
2153 if (IsChanPrefix(*yylval.string))
2154 {
2155 char def_reason[] = "No reason";
2156
2157 create_channel_resv(yylval.string, resv_reason != NULL ? resv_reason : def_reason, 1);
2158 }
2159 }
2160 /* ignore it for now.. but we really should make a warning if
2161 * its an erroneous name --fl_ */
2162 };
2163
2164 resv_nick: NICK '=' QSTRING ';'
2165 {
2166 if (ypass == 2)
2167 {
2168 char def_reason[] = "No reason";
2169
2170 create_nick_resv(yylval.string, resv_reason != NULL ? resv_reason : def_reason, 1);
2171 }
2172 };
2173
2174 /***************************************************************************
2175 * section shared, for sharing remote klines etc.
2176 ***************************************************************************/
2177 shared_entry: T_SHARED
2178 {
2179 if (ypass == 2)
2180 {
2181 yy_conf = make_conf_item(ULINE_TYPE);
2182 yy_match_item = map_to_conf(yy_conf);
2183 yy_match_item->action = SHARED_ALL;
2184 }
2185 } '{' shared_items '}' ';'
2186 {
2187 if (ypass == 2)
2188 {
2189 yy_conf = NULL;
2190 }
2191 };
2192
2193 shared_items: shared_items shared_item | shared_item;
2194 shared_item: shared_name | shared_user | shared_type | error ';' ;
2195
2196 shared_name: NAME '=' QSTRING ';'
2197 {
2198 if (ypass == 2)
2199 {
2200 MyFree(yy_conf->name);
2201 DupString(yy_conf->name, yylval.string);
2202 }
2203 };
2204
2205 shared_user: USER '=' QSTRING ';'
2206 {
2207 if (ypass == 2)
2208 {
2209 split_nuh(yylval.string, NULL, &yy_match_item->user, &yy_match_item->host);
2210 }
2211 };
2212
2213 shared_type: TYPE
2214 {
2215 if (ypass == 2)
2216 yy_match_item->action = 0;
2217 } '=' shared_types ';' ;
2218
2219 shared_types: shared_types ',' shared_type_item | shared_type_item;
2220 shared_type_item: KLINE
2221 {
2222 if (ypass == 2)
2223 yy_match_item->action |= SHARED_KLINE;
2224 } | TKLINE
2225 {
2226 if (ypass == 2)
2227 yy_match_item->action |= SHARED_TKLINE;
2228 } | UNKLINE
2229 {
2230 if (ypass == 2)
2231 yy_match_item->action |= SHARED_UNKLINE;
2232 } | XLINE
2233 {
2234 if (ypass == 2)
2235 yy_match_item->action |= SHARED_XLINE;
2236 } | TXLINE
2237 {
2238 if (ypass == 2)
2239 yy_match_item->action |= SHARED_TXLINE;
2240 } | T_UNXLINE
2241 {
2242 if (ypass == 2)
2243 yy_match_item->action |= SHARED_UNXLINE;
2244 } | RESV
2245 {
2246 if (ypass == 2)
2247 yy_match_item->action |= SHARED_RESV;
2248 } | TRESV
2249 {
2250 if (ypass == 2)
2251 yy_match_item->action |= SHARED_TRESV;
2252 } | T_UNRESV
2253 {
2254 if (ypass == 2)
2255 yy_match_item->action |= SHARED_UNRESV;
2256 } | T_LOCOPS
2257 {
2258 if (ypass == 2)
2259 yy_match_item->action |= SHARED_LOCOPS;
2260 } | T_ALL
2261 {
2262 if (ypass == 2)
2263 yy_match_item->action = SHARED_ALL;
2264 };
2265
2266 /***************************************************************************
2267 * section cluster
2268 ***************************************************************************/
2269 cluster_entry: T_CLUSTER
2270 {
2271 if (ypass == 2)
2272 {
2273 yy_conf = make_conf_item(CLUSTER_TYPE);
2274 yy_conf->flags = SHARED_ALL;
2275 }
2276 } '{' cluster_items '}' ';'
2277 {
2278 if (ypass == 2)
2279 {
2280 if (yy_conf->name == NULL)
2281 DupString(yy_conf->name, "*");
2282 yy_conf = NULL;
2283 }
2284 };
2285
2286 cluster_items: cluster_items cluster_item | cluster_item;
2287 cluster_item: cluster_name | cluster_type | error ';' ;
2288
2289 cluster_name: NAME '=' QSTRING ';'
2290 {
2291 if (ypass == 2)
2292 DupString(yy_conf->name, yylval.string);
2293 };
2294
2295 cluster_type: TYPE
2296 {
2297 if (ypass == 2)
2298 yy_conf->flags = 0;
2299 } '=' cluster_types ';' ;
2300
2301 cluster_types: cluster_types ',' cluster_type_item | cluster_type_item;
2302 cluster_type_item: KLINE
2303 {
2304 if (ypass == 2)
2305 yy_conf->flags |= SHARED_KLINE;
2306 } | TKLINE
2307 {
2308 if (ypass == 2)
2309 yy_conf->flags |= SHARED_TKLINE;
2310 } | UNKLINE
2311 {
2312 if (ypass == 2)
2313 yy_conf->flags |= SHARED_UNKLINE;
2314 } | XLINE
2315 {
2316 if (ypass == 2)
2317 yy_conf->flags |= SHARED_XLINE;
2318 } | TXLINE
2319 {
2320 if (ypass == 2)
2321 yy_conf->flags |= SHARED_TXLINE;
2322 } | T_UNXLINE
2323 {
2324 if (ypass == 2)
2325 yy_conf->flags |= SHARED_UNXLINE;
2326 } | RESV
2327 {
2328 if (ypass == 2)
2329 yy_conf->flags |= SHARED_RESV;
2330 } | TRESV
2331 {
2332 if (ypass == 2)
2333 yy_conf->flags |= SHARED_TRESV;
2334 } | T_UNRESV
2335 {
2336 if (ypass == 2)
2337 yy_conf->flags |= SHARED_UNRESV;
2338 } | T_LOCOPS
2339 {
2340 if (ypass == 2)
2341 yy_conf->flags |= SHARED_LOCOPS;
2342 } | T_ALL
2343 {
2344 if (ypass == 2)
2345 yy_conf->flags = SHARED_ALL;
2346 };
2347
2348 /***************************************************************************
2349 * section connect
2350 ***************************************************************************/
2351 connect_entry: CONNECT
2352 {
2353 if (ypass == 2)
2354 {
2355 yy_conf = make_conf_item(SERVER_TYPE);
2356 yy_aconf = (struct AccessItem *)map_to_conf(yy_conf);
2357 yy_aconf->passwd = NULL;
2358 /* defaults */
2359 yy_aconf->port = PORTNUM;
2360
2361 if (ConfigFileEntry.burst_away)
2362 yy_aconf->flags = CONF_FLAGS_BURST_AWAY;
2363 }
2364 else
2365 {
2366 MyFree(class_name);
2367 class_name = NULL;
2368 }
2369 } connect_name_b '{' connect_items '}' ';'
2370 {
2371 if (ypass == 2)
2372 {
2373 struct CollectItem *yy_hconf=NULL;
2374 struct CollectItem *yy_lconf=NULL;
2375 dlink_node *ptr;
2376 dlink_node *next_ptr;
2377 #ifdef HAVE_LIBCRYPTO
2378 if (yy_aconf->host &&
2379 ((yy_aconf->passwd && yy_aconf->spasswd) ||
2380 (yy_aconf->rsa_public_key && IsConfCryptLink(yy_aconf))))
2381 #else /* !HAVE_LIBCRYPTO */
2382 if (yy_aconf->host && !IsConfCryptLink(yy_aconf) &&
2383 yy_aconf->passwd && yy_aconf->spasswd)
2384 #endif /* !HAVE_LIBCRYPTO */
2385 {
2386 if (conf_add_server(yy_conf, scount, class_name) >= 0)
2387 {
2388 ++scount;
2389 }
2390 else
2391 {
2392 delete_conf_item(yy_conf);
2393 yy_conf = NULL;
2394 yy_aconf = NULL;
2395 }
2396 }
2397 else
2398 {
2399 /* Even if yy_conf ->name is NULL
2400 * should still unhook any hub/leaf confs still pending
2401 */
2402 unhook_hub_leaf_confs();
2403
2404 if (yy_conf->name != NULL)
2405 {
2406 #ifndef HAVE_LIBCRYPTO
2407 if (IsConfCryptLink(yy_aconf))
2408 yyerror("Ignoring connect block -- no OpenSSL support");
2409 #else
2410 if (IsConfCryptLink(yy_aconf) && !yy_aconf->rsa_public_key)
2411 yyerror("Ignoring connect block -- missing key");
2412 #endif
2413 if (yy_aconf->host == NULL)
2414 yyerror("Ignoring connect block -- missing host");
2415 else if (!IsConfCryptLink(yy_aconf) &&
2416 (!yy_aconf->passwd || !yy_aconf->spasswd))
2417 yyerror("Ignoring connect block -- missing password");
2418 }
2419
2420
2421 /* XXX
2422 * This fixes a try_connections() core (caused by invalid class_ptr
2423 * pointers) reported by metalrock. That's an ugly fix, but there
2424 * is currently no better way. The entire config subsystem needs an
2425 * rewrite ASAP. make_conf_item() shouldn't really add things onto
2426 * a doubly linked list immediately without any sanity checks! -Michael
2427 */
2428 delete_conf_item(yy_conf);
2429
2430 yy_aconf = NULL;
2431 yy_conf = NULL;
2432 }
2433
2434 /*
2435 * yy_conf is still pointing at the server that is having
2436 * a connect block built for it. This means, y_aconf->name
2437 * points to the actual irc name this server will be known as.
2438 * Now this new server has a set or even just one hub_mask (or leaf_mask)
2439 * given in the link list at yy_hconf. Fill in the HUB confs
2440 * from this link list now.
2441 */
2442 DLINK_FOREACH_SAFE(ptr, next_ptr, hub_conf_list.head)
2443 {
2444 struct ConfItem *new_hub_conf;
2445 struct MatchItem *match_item;
2446
2447 yy_hconf = ptr->data;
2448
2449 /* yy_conf == NULL is a fatal error for this connect block! */
2450 if ((yy_conf != NULL) && (yy_conf->name != NULL))
2451 {
2452 new_hub_conf = make_conf_item(HUB_TYPE);
2453 match_item = (struct MatchItem *)map_to_conf(new_hub_conf);
2454 DupString(new_hub_conf->name, yy_conf->name);
2455 if (yy_hconf->user != NULL)
2456 DupString(match_item->user, yy_hconf->user);
2457 else
2458 DupString(match_item->user, "*");
2459 if (yy_hconf->host != NULL)
2460 DupString(match_item->host, yy_hconf->host);
2461 else
2462 DupString(match_item->host, "*");
2463 }
2464 dlinkDelete(&yy_hconf->node, &hub_conf_list);
2465 free_collect_item(yy_hconf);
2466 }
2467
2468 /* Ditto for the LEAF confs */
2469
2470 DLINK_FOREACH_SAFE(ptr, next_ptr, leaf_conf_list.head)
2471 {
2472 struct ConfItem *new_leaf_conf;
2473 struct MatchItem *match_item;
2474
2475 yy_lconf = ptr->data;
2476
2477 if ((yy_conf != NULL) && (yy_conf->name != NULL))
2478 {
2479 new_leaf_conf = make_conf_item(LEAF_TYPE);
2480 match_item = (struct MatchItem *)map_to_conf(new_leaf_conf);
2481 DupString(new_leaf_conf->name, yy_conf->name);
2482 if (yy_lconf->user != NULL)
2483 DupString(match_item->user, yy_lconf->user);
2484 else
2485 DupString(match_item->user, "*");
2486 if (yy_lconf->host != NULL)
2487 DupString(match_item->host, yy_lconf->host);
2488 else
2489 DupString(match_item->host, "*");
2490 }
2491 dlinkDelete(&yy_lconf->node, &leaf_conf_list);
2492 free_collect_item(yy_lconf);
2493 }
2494 MyFree(class_name);
2495 class_name = NULL;
2496 yy_conf = NULL;
2497 yy_aconf = NULL;
2498 }
2499 };
2500
2501 connect_name_b: | connect_name_t;
2502 connect_items: connect_items connect_item | connect_item;
2503 connect_item: connect_name | connect_host | connect_vhost |
2504 connect_send_password | connect_accept_password |
2505 connect_aftype | connect_port |
2506 connect_fakename | connect_flags | connect_hub_mask |
2507 connect_leaf_mask | connect_class | connect_auto |
2508 connect_encrypted | connect_compressed | connect_cryptlink |
2509 connect_rsa_public_key_file | connect_cipher_preference |
2510 connect_topicburst | error ';' ;
2511
2512 connect_name: NAME '=' QSTRING ';'
2513 {
2514 if (ypass == 2)
2515 {
2516 if (yy_conf->name != NULL)
2517 yyerror("Multiple connect name entry");
2518
2519 MyFree(yy_conf->name);
2520 DupString(yy_conf->name, yylval.string);
2521 }
2522 };
2523
2524 connect_name_t: QSTRING
2525 {
2526 if (ypass == 2)
2527 {
2528 if (yy_conf->name != NULL)
2529 yyerror("Multiple connect name entry");
2530
2531 MyFree(yy_conf->name);
2532 DupString(yy_conf->name, yylval.string);
2533 }
2534 };
2535
2536 connect_host: HOST '=' QSTRING ';'
2537 {
2538 if (ypass == 2)
2539 {
2540 MyFree(yy_aconf->host);
2541 DupString(yy_aconf->host, yylval.string);
2542 }
2543 };
2544
2545 connect_vhost: VHOST '=' QSTRING ';'
2546 {
2547 if (ypass == 2)
2548 {
2549 struct addrinfo hints, *res;
2550
2551 memset(&hints, 0, sizeof(hints));
2552
2553 hints.ai_family = AF_UNSPEC;
2554 hints.ai_socktype = SOCK_STREAM;
2555 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
2556
2557 if (irc_getaddrinfo(yylval.string, NULL, &hints, &res))
2558 ilog(L_ERROR, "Invalid netmask for server vhost(%s)", yylval.string);
2559 else
2560 {
2561 assert(res != NULL);
2562
2563 memcpy(&yy_aconf->my_ipnum, res->ai_addr, res->ai_addrlen);
2564 yy_aconf->my_ipnum.ss.ss_family = res->ai_family;
2565 yy_aconf->my_ipnum.ss_len = res->ai_addrlen;
2566 irc_freeaddrinfo(res);
2567 }
2568 }
2569 };
2570
2571 connect_send_password: SEND_PASSWORD '=' QSTRING ';'
2572 {
2573 if (ypass == 2)
2574 {
2575 if ($3[0] == ':')
2576 yyerror("Server passwords cannot begin with a colon");
2577 else if (strchr($3, ' ') != NULL)
2578 yyerror("Server passwords cannot contain spaces");
2579 else {
2580 if (yy_aconf->spasswd != NULL)
2581 memset(yy_aconf->spasswd, 0, strlen(yy_aconf->spasswd));
2582
2583 MyFree(yy_aconf->spasswd);
2584 DupString(yy_aconf->spasswd, yylval.string);
2585 }
2586 }
2587 };
2588
2589 connect_accept_password: ACCEPT_PASSWORD '=' QSTRING ';'
2590 {
2591 if (ypass == 2)
2592 {
2593 if ($3[0] == ':')
2594 yyerror("Server passwords cannot begin with a colon");
2595 else if (strchr($3, ' ') != NULL)
2596 yyerror("Server passwords cannot contain spaces");
2597 else {
2598 if (yy_aconf->passwd != NULL)
2599 memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
2600
2601 MyFree(yy_aconf->passwd);
2602 DupString(yy_aconf->passwd, yylval.string);
2603 }
2604 }
2605 };
2606
2607 connect_port: PORT '=' NUMBER ';'
2608 {
2609 if (ypass == 2)
2610 yy_aconf->port = $3;
2611 };
2612
2613 connect_aftype: AFTYPE '=' T_IPV4 ';'
2614 {
2615 if (ypass == 2)
2616 yy_aconf->aftype = AF_INET;
2617 } | AFTYPE '=' T_IPV6 ';'
2618 {
2619 #ifdef IPV6
2620 if (ypass == 2)
2621 yy_aconf->aftype = AF_INET6;
2622 #endif
2623 };
2624
2625 connect_fakename: FAKENAME '=' QSTRING ';'
2626 {
2627 if (ypass == 2)
2628 {
2629 MyFree(yy_aconf->fakename);
2630 DupString(yy_aconf->fakename, yylval.string);
2631 }
2632 };
2633
2634 connect_flags: IRCD_FLAGS
2635 {
2636 } '=' connect_flags_items ';';
2637
2638 connect_flags_items: connect_flags_items ',' connect_flags_item | connect_flags_item;
2639 connect_flags_item: NOT { not_atom = 1; } connect_flags_item_atom
2640 | { not_atom = 0; } connect_flags_item_atom;
2641
2642 connect_flags_item_atom: LAZYLINK
2643 {
2644 if (ypass == 2)
2645 {
2646 if (not_atom)ClearConfLazyLink(yy_aconf);
2647 else SetConfLazyLink(yy_aconf);
2648 }
2649 } | COMPRESSED
2650 {
2651 if (ypass == 2)
2652 #ifndef HAVE_LIBZ
2653 yyerror("Ignoring flags = compressed; -- no zlib support");
2654 #else
2655 {
2656 if (not_atom)ClearConfCompressed(yy_aconf);
2657 else SetConfCompressed(yy_aconf);
2658 }
2659 #endif
2660 } | CRYPTLINK
2661 {
2662 if (ypass == 2)
2663 {
2664 if (not_atom)ClearConfCryptLink(yy_aconf);
2665 else SetConfCryptLink(yy_aconf);
2666 }
2667 } | AUTOCONN
2668 {
2669 if (ypass == 2)
2670 {
2671 if (not_atom)ClearConfAllowAutoConn(yy_aconf);
2672 else SetConfAllowAutoConn(yy_aconf);
2673 }
2674 } | BURST_AWAY
2675 {
2676 if (ypass == 2)
2677 {
2678 if (not_atom)ClearConfAwayBurst(yy_aconf);
2679 else SetConfAwayBurst(yy_aconf);
2680 }
2681 } | TOPICBURST
2682 {
2683 if (ypass == 2)
2684 {
2685 if (not_atom)ClearConfTopicBurst(yy_aconf);
2686 else SetConfTopicBurst(yy_aconf);
2687 }
2688 }
2689 ;
2690
2691 connect_rsa_public_key_file: RSA_PUBLIC_KEY_FILE '=' QSTRING ';'
2692 {
2693 #ifdef HAVE_LIBCRYPTO
2694 if (ypass == 2)
2695 {
2696 BIO *file;
2697
2698 if (yy_aconf->rsa_public_key != NULL)
2699 {
2700 RSA_free(yy_aconf->rsa_public_key);
2701 yy_aconf->rsa_public_key = NULL;
2702 }
2703
2704 if (yy_aconf->rsa_public_key_file != NULL)
2705 {
2706 MyFree(yy_aconf->rsa_public_key_file);
2707 yy_aconf->rsa_public_key_file = NULL;
2708 }
2709
2710 DupString(yy_aconf->rsa_public_key_file, yylval.string);
2711
2712 if ((file = BIO_new_file(yylval.string, "r")) == NULL)
2713 {
2714 yyerror("Ignoring rsa_public_key_file -- file doesn't exist");
2715 break;
2716 }
2717
2718 yy_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
2719
2720 if (yy_aconf->rsa_public_key == NULL)
2721 {
2722 yyerror("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
2723 break;
2724 }
2725
2726 BIO_set_close(file, BIO_CLOSE);
2727 BIO_free(file);
2728 }
2729 #endif /* HAVE_LIBCRYPTO */
2730 };
2731
2732 connect_encrypted: ENCRYPTED '=' TBOOL ';'
2733 {
2734 if (ypass == 2)
2735 {
2736 if (yylval.number)
2737 yy_aconf->flags |= CONF_FLAGS_ENCRYPTED;
2738 else
2739 yy_aconf->flags &= ~CONF_FLAGS_ENCRYPTED;
2740 }
2741 };
2742
2743 connect_cryptlink: CRYPTLINK '=' TBOOL ';'
2744 {
2745 if (ypass == 2)
2746 {
2747 if (yylval.number)
2748 yy_aconf->flags |= CONF_FLAGS_CRYPTLINK;
2749 else
2750 yy_aconf->flags &= ~CONF_FLAGS_CRYPTLINK;
2751 }
2752 };
2753
2754 connect_compressed: COMPRESSED '=' TBOOL ';'
2755 {
2756 if (ypass == 2)
2757 {
2758 if (yylval.number)
2759 #ifndef HAVE_LIBZ
2760 yyerror("Ignoring compressed=yes; -- no zlib support");
2761 #else
2762 yy_aconf->flags |= CONF_FLAGS_COMPRESSED;
2763 #endif
2764 else
2765 yy_aconf->flags &= ~CONF_FLAGS_COMPRESSED;
2766 }
2767 };
2768
2769 connect_auto: AUTOCONN '=' TBOOL ';'
2770 {
2771 if (ypass == 2)
2772 {
2773 if (yylval.number)
2774 yy_aconf->flags |= CONF_FLAGS_ALLOW_AUTO_CONN;
2775 else
2776 yy_aconf->flags &= ~CONF_FLAGS_ALLOW_AUTO_CONN;
2777 }
2778 };
2779
2780 connect_topicburst: TOPICBURST '=' TBOOL ';'
2781 {
2782 if (ypass == 2)
2783 {
2784 if (yylval.number)
2785 SetConfTopicBurst(yy_aconf);
2786 else
2787 ClearConfTopicBurst(yy_aconf);
2788 }
2789 };
2790
2791 connect_hub_mask: HUB_MASK '=' QSTRING ';'
2792 {
2793 if (ypass == 2)
2794 {
2795 struct CollectItem *yy_tmp;
2796
2797 yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
2798 DupString(yy_tmp->host, yylval.string);
2799 DupString(yy_tmp->user, "*");
2800 dlinkAdd(yy_tmp, &yy_tmp->node, &hub_conf_list);
2801 }
2802 };
2803
2804 connect_leaf_mask: LEAF_MASK '=' QSTRING ';'
2805 {
2806 if (ypass == 2)
2807 {
2808 struct CollectItem *yy_tmp;
2809
2810 yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
2811 DupString(yy_tmp->host, yylval.string);
2812 DupString(yy_tmp->user, "*");
2813 dlinkAdd(yy_tmp, &yy_tmp->node, &leaf_conf_list);
2814 }
2815 };
2816
2817 connect_class: CLASS '=' QSTRING ';'
2818 {
2819 if (ypass == 2)
2820 {
2821 MyFree(class_name);
2822 DupString(class_name, yylval.string);
2823 }
2824 };
2825
2826 connect_cipher_preference: CIPHER_PREFERENCE '=' QSTRING ';'
2827 {
2828 #ifdef HAVE_LIBCRYPTO
2829 if (ypass == 2)
2830 {
2831 struct EncCapability *ecap;
2832 const char *cipher_name;
2833 int found = 0;
2834
2835 yy_aconf->cipher_preference = NULL;
2836 cipher_name = yylval.string;
2837
2838 for (ecap = CipherTable; ecap->name; ecap++)
2839 {
2840 if ((irccmp(ecap->name, cipher_name) == 0) &&
2841 (ecap->cap & CAP_ENC_MASK))
2842 {
2843 yy_aconf->cipher_preference = ecap;
2844 found = 1;
2845 break;
2846 }
2847 }
2848
2849 if (!found)
2850 yyerror("Invalid cipher");
2851 }
2852 #else
2853 if (ypass == 2)
2854 yyerror("Ignoring cipher_preference -- no OpenSSL support");
2855 #endif
2856 };
2857
2858 /***************************************************************************
2859 * section kill
2860 ***************************************************************************/
2861 kill_entry: KILL
2862 {
2863 if (ypass == 2)
2864 {
2865 userbuf[0] = hostbuf[0] = reasonbuf[0] = '\0';
2866 regex_ban = 0;
2867 }
2868 } '{' kill_items '}' ';'
2869 {
2870 if (ypass == 2)
2871 {
2872 if (userbuf[0] && hostbuf[0])
2873 {
2874 if (regex_ban)
2875 {
2876 pcre *exp_user = NULL;
2877 pcre *exp_host = NULL;
2878 const char *errptr = NULL;
2879
2880 if (!(exp_user = ircd_pcre_compile(userbuf, &errptr)) ||
2881 !(exp_host = ircd_pcre_compile(hostbuf, &errptr)))
2882 {
2883 ilog(L_ERROR, "Failed to add regular expression based K-Line: %s", errptr);
2884 break;
2885 }
2886
2887 yy_conf = make_conf_item(RKLINE_TYPE);
2888 yy_aconf->regexuser = exp_user;
2889 yy_aconf->regexhost = exp_host;
2890
2891 DupString(yy_aconf->user, userbuf);
2892 DupString(yy_aconf->host, hostbuf);
2893
2894 if (reasonbuf[0])
2895 DupString(yy_aconf->reason, reasonbuf);
2896 else
2897 DupString(yy_aconf->reason, "No reason");
2898 }
2899 else
2900 {
2901 yy_conf = make_conf_item(KLINE_TYPE);
2902 yy_aconf = map_to_conf(yy_conf);
2903
2904 DupString(yy_aconf->user, userbuf);
2905 DupString(yy_aconf->host, hostbuf);
2906
2907 if (reasonbuf[0])
2908 DupString(yy_aconf->reason, reasonbuf);
2909 else
2910 DupString(yy_aconf->reason, "No reason");
2911 add_conf_by_address(CONF_KILL, yy_aconf);
2912 }
2913 }
2914 else
2915 delete_conf_item(yy_conf);
2916
2917 yy_conf = NULL;
2918 yy_aconf = NULL;
2919 }
2920 };
2921
2922 kill_type: TYPE
2923 {
2924 } '=' kill_type_items ';';
2925
2926 kill_type_items: kill_type_items ',' kill_type_item | kill_type_item;
2927 kill_type_item: REGEX_T
2928 {
2929 if (ypass == 2)
2930 regex_ban = 1;
2931 };
2932
2933 kill_items: kill_items kill_item | kill_item;
2934 kill_item: kill_user | kill_reason | kill_type | error;
2935
2936 kill_user: USER '=' QSTRING ';'
2937 {
2938 if (ypass == 2)
2939 {
2940 char *user = NULL, *host = NULL;
2941
2942 split_nuh(yylval.string, NULL, &user, &host);
2943
2944 strlcpy(userbuf, user, sizeof(userbuf));
2945 strlcpy(hostbuf, host, sizeof(hostbuf));
2946
2947 MyFree(user);
2948 MyFree(host);
2949 }
2950 };
2951
2952 kill_reason: REASON '=' QSTRING ';'
2953 {
2954 if (ypass == 2)
2955 strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
2956 };
2957
2958 /***************************************************************************
2959 * section deny
2960 ***************************************************************************/
2961 deny_entry: DENY
2962 {
2963 if (ypass == 2)
2964 {
2965 yy_conf = make_conf_item(DLINE_TYPE);
2966 yy_aconf = map_to_conf(yy_conf);
2967 /* default reason */
2968 DupString(yy_aconf->reason, "No reason");
2969 }
2970 } '{' deny_items '}' ';'
2971 {
2972 if (ypass == 2)
2973 {
2974 if (yy_aconf->host && parse_netmask(yy_aconf->host, NULL, NULL) != HM_HOST)
2975 add_conf_by_address(CONF_DLINE, yy_aconf);
2976 else
2977 delete_conf_item(yy_conf);
2978 yy_conf = NULL;
2979 yy_aconf = NULL;
2980 }
2981 };
2982
2983 deny_items: deny_items deny_item | deny_item;
2984 deny_item: deny_ip | deny_reason | error;
2985
2986 deny_ip: IP '=' QSTRING ';'
2987 {
2988 if (ypass == 2)
2989 {
2990 MyFree(yy_aconf->host);
2991 DupString(yy_aconf->host, yylval.string);
2992 }
2993 };
2994
2995 deny_reason: REASON '=' QSTRING ';'
2996 {
2997 if (ypass == 2)
2998 {
2999 MyFree(yy_aconf->reason);
3000 DupString(yy_aconf->reason, yylval.string);
3001 }
3002 };
3003
3004 /***************************************************************************
3005 * section exempt
3006 ***************************************************************************/
3007 exempt_entry: EXEMPT '{' exempt_items '}' ';';
3008
3009 exempt_items: exempt_items exempt_item | exempt_item;
3010 exempt_item: exempt_ip | error;
3011
3012 exempt_ip: IP '=' QSTRING ';'
3013 {
3014 if (ypass == 2)
3015 {
3016 if (yylval.string[0] && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
3017 {
3018 yy_conf = make_conf_item(EXEMPTDLINE_TYPE);
3019 yy_aconf = map_to_conf(yy_conf);
3020 DupString(yy_aconf->host, yylval.string);
3021
3022 add_conf_by_address(CONF_EXEMPTDLINE, yy_aconf);
3023
3024 yy_conf = NULL;
3025 yy_aconf = NULL;
3026 }
3027 }
3028 };
3029
3030 /***************************************************************************
3031 * section gecos
3032 ***************************************************************************/
3033 gecos_entry: GECOS
3034 {
3035 if (ypass == 2)
3036 {
3037 regex_ban = 0;
3038 reasonbuf[0] = gecos_name[0] = '\0';
3039 }
3040 } '{' gecos_items '}' ';'
3041 {
3042 if (ypass == 2)
3043 {
3044 if (gecos_name[0])
3045 {
3046 if (regex_ban)
3047 {
3048 pcre *exp_p = NULL;
3049 const char *errptr = NULL;
3050
3051 if (!(exp_p = ircd_pcre_compile(gecos_name, &errptr)))
3052 {
3053 ilog(L_ERROR, "Failed to add regular expression based X-Line: %s", errptr);
3054 break;
3055 }
3056
3057 yy_conf = make_conf_item(RXLINE_TYPE);
3058 yy_conf->regexpname = exp_p;
3059 }
3060 else
3061 yy_conf = make_conf_item(XLINE_TYPE);
3062
3063 yy_match_item = map_to_conf(yy_conf);
3064 DupString(yy_conf->name, gecos_name);
3065
3066 if (reasonbuf[0])
3067 DupString(yy_match_item->reason, reasonbuf);
3068 else
3069 DupString(yy_match_item->reason, "No reason");
3070 }
3071 }
3072 };
3073
3074 gecos_flags: TYPE
3075 {
3076 } '=' gecos_flags_items ';';
3077
3078 gecos_flags_items: gecos_flags_items ',' gecos_flags_item | gecos_flags_item;
3079 gecos_flags_item: REGEX_T
3080 {
3081 if (ypass == 2)
3082 regex_ban = 1;
3083 };
3084
3085 gecos_items: gecos_items gecos_item | gecos_item;
3086 gecos_item: gecos_name | gecos_reason | gecos_flags | error;
3087
3088 gecos_name: NAME '=' QSTRING ';'
3089 {
3090 if (ypass == 2)
3091 strlcpy(gecos_name, yylval.string, sizeof(gecos_name));
3092 };
3093
3094 gecos_reason: REASON '=' QSTRING ';'
3095 {
3096 if (ypass == 2)
3097 strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
3098 };
3099
3100 /***************************************************************************
3101 * section general
3102 ***************************************************************************/
3103 general_entry: GENERAL
3104 '{' general_items '}' ';';
3105
3106 general_items: general_items general_item | general_item;
3107 general_item: general_hide_spoof_ips | general_ignore_bogus_ts |
3108 general_failed_oper_notice | general_anti_nick_flood |
3109 general_max_nick_time | general_max_nick_changes |
3110 general_max_accept | general_anti_spam_exit_message_time |
3111 general_ts_warn_delta | general_ts_max_delta |
3112 general_kill_chase_time_limit | general_kline_with_reason |
3113 general_kline_reason | general_invisible_on_connect |
3114 general_warn_no_nline | general_dots_in_ident |
3115 general_stats_o_oper_only | general_stats_k_oper_only |
3116 general_pace_wait | general_stats_i_oper_only |
3117 general_pace_wait_simple | general_stats_P_oper_only |
3118 general_short_motd | general_no_oper_flood |
3119 general_true_no_oper_flood | general_oper_pass_resv |
3120 general_idletime | general_message_locale |
3121 general_oper_only_umodes | general_max_targets |
3122 general_use_egd | general_egdpool_path |
3123 general_oper_umodes | general_caller_id_wait |
3124 general_opers_bypass_callerid | general_default_floodcount |
3125 general_min_nonwildcard | general_min_nonwildcard_simple |
3126 general_servlink_path | general_disable_remote_commands |
3127 general_default_cipher_preference |
3128 general_compression_level | general_client_flood |
3129 general_throttle_time | general_havent_read_conf |
3130 general_dot_in_ip6_addr | general_ping_cookie |
3131 general_disable_auth | general_burst_away |
3132 general_tkline_expire_notices | general_gline_min_cidr |
3133 general_gline_min_cidr6 | general_use_whois_actually |
3134 general_reject_hold_time |
3135 error;
3136
3137
3138
3139 general_gline_min_cidr: GLINE_MIN_CIDR '=' NUMBER ';'
3140 {
3141 ConfigFileEntry.gline_min_cidr = $3;
3142 };
3143
3144 general_gline_min_cidr6: GLINE_MIN_CIDR6 '=' NUMBER ';'
3145 {
3146 ConfigFileEntry.gline_min_cidr6 = $3;
3147 };
3148
3149 general_burst_away: BURST_AWAY '=' TBOOL ';'
3150 {
3151 ConfigFileEntry.burst_away = yylval.number;
3152 };
3153
3154 general_use_whois_actually: USE_WHOIS_ACTUALLY '=' TBOOL ';'
3155 {
3156 ConfigFileEntry.use_whois_actually = yylval.number;
3157 };
3158
3159 general_reject_hold_time: TREJECT_HOLD_TIME '=' timespec ';'
3160 {
3161 GlobalSetOptions.rejecttime = yylval.number;
3162 };
3163
3164 general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
3165 {
3166 ConfigFileEntry.tkline_expire_notices = yylval.number;
3167 };
3168
3169 general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' NUMBER ';'
3170 {
3171 ConfigFileEntry.kill_chase_time_limit = $3;
3172 };
3173
3174 general_hide_spoof_ips: HIDE_SPOOF_IPS '=' TBOOL ';'
3175 {
3176 ConfigFileEntry.hide_spoof_ips = yylval.number;
3177 };
3178
3179 general_ignore_bogus_ts: IGNORE_BOGUS_TS '=' TBOOL ';'
3180 {
3181 ConfigFileEntry.ignore_bogus_ts = yylval.number;
3182 };
3183
3184 general_disable_remote_commands: DISABLE_REMOTE_COMMANDS '=' TBOOL ';'
3185 {
3186 ConfigFileEntry.disable_remote = yylval.number;
3187 };
3188
3189 general_failed_oper_notice: FAILED_OPER_NOTICE '=' TBOOL ';'
3190 {
3191 ConfigFileEntry.failed_oper_notice = yylval.number;
3192 };
3193
3194 general_anti_nick_flood: ANTI_NICK_FLOOD '=' TBOOL ';'
3195 {
3196 ConfigFileEntry.anti_nick_flood = yylval.number;
3197 };
3198
3199 general_max_nick_time: MAX_NICK_TIME '=' timespec ';'
3200 {
3201 ConfigFileEntry.max_nick_time = $3;
3202 };
3203
3204 general_max_nick_changes: MAX_NICK_CHANGES '=' NUMBER ';'
3205 {
3206 ConfigFileEntry.max_nick_changes = $3;
3207 };
3208
3209 general_max_accept: MAX_ACCEPT '=' NUMBER ';'
3210 {
3211 ConfigFileEntry.max_accept = $3;
3212 };
3213
3214 general_anti_spam_exit_message_time: ANTI_SPAM_EXIT_MESSAGE_TIME '=' timespec ';'
3215 {
3216 ConfigFileEntry.anti_spam_exit_message_time = $3;
3217 };
3218
3219 general_ts_warn_delta: TS_WARN_DELTA '=' timespec ';'
3220 {
3221 ConfigFileEntry.ts_warn_delta = $3;
3222 };
3223
3224 general_ts_max_delta: TS_MAX_DELTA '=' timespec ';'
3225 {
3226 if (ypass == 2)
3227 ConfigFileEntry.ts_max_delta = $3;
3228 };
3229
3230 general_havent_read_conf: HAVENT_READ_CONF '=' NUMBER ';'
3231 {
3232 if (($3 > 0) && ypass == 1)
3233 {
3234 ilog(L_CRIT, "You haven't read your config file properly.");
3235 ilog(L_CRIT, "There is a line in the example conf that will kill your server if not removed.");
3236 ilog(L_CRIT, "Consider actually reading/editing the conf file, and removing this line.");
3237 exit(0);
3238 }
3239 };
3240
3241 general_kline_with_reason: KLINE_WITH_REASON '=' TBOOL ';'
3242 {
3243 ConfigFileEntry.kline_with_reason = yylval.number;
3244 };
3245
3246 general_kline_reason: KLINE_REASON '=' QSTRING ';'
3247 {
3248 if (ypass == 2)
3249 {
3250 MyFree(ConfigFileEntry.kline_reason);
3251 DupString(ConfigFileEntry.kline_reason, yylval.string);
3252 }
3253 };
3254
3255 general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
3256 {
3257 ConfigFileEntry.invisible_on_connect = yylval.number;
3258 };
3259
3260 general_warn_no_nline: WARN_NO_NLINE '=' TBOOL ';'
3261 {
3262 ConfigFileEntry.warn_no_nline = yylval.number;
3263 };
3264
3265 general_stats_o_oper_only: STATS_O_OPER_ONLY '=' TBOOL ';'
3266 {
3267 ConfigFileEntry.stats_o_oper_only = yylval.number;
3268 };
3269
3270 general_stats_P_oper_only: STATS_P_OPER_ONLY '=' TBOOL ';'
3271 {
3272 ConfigFileEntry.stats_P_oper_only = yylval.number;
3273 };
3274
3275 general_stats_k_oper_only: STATS_K_OPER_ONLY '=' TBOOL ';'
3276 {
3277 ConfigFileEntry.stats_k_oper_only = 2 * yylval.number;
3278 } | STATS_K_OPER_ONLY '=' TMASKED ';'
3279 {
3280 ConfigFileEntry.stats_k_oper_only = 1;
3281 };
3282
3283 general_stats_i_oper_only: STATS_I_OPER_ONLY '=' TBOOL ';'
3284 {
3285 ConfigFileEntry.stats_i_oper_only = 2 * yylval.number;
3286 } | STATS_I_OPER_ONLY '=' TMASKED ';'
3287 {
3288 ConfigFileEntry.stats_i_oper_only = 1;
3289 };
3290
3291 general_pace_wait: PACE_WAIT '=' timespec ';'
3292 {
3293 ConfigFileEntry.pace_wait = $3;
3294 };
3295
3296 general_caller_id_wait: CALLER_ID_WAIT '=' timespec ';'
3297 {
3298 ConfigFileEntry.caller_id_wait = $3;
3299 };
3300
3301 general_opers_bypass_callerid: OPERS_BYPASS_CALLERID '=' TBOOL ';'
3302 {
3303 ConfigFileEntry.opers_bypass_callerid = yylval.number;
3304 };
3305
3306 general_pace_wait_simple: PACE_WAIT_SIMPLE '=' timespec ';'
3307 {
3308 ConfigFileEntry.pace_wait_simple = $3;
3309 };
3310
3311 general_short_motd: SHORT_MOTD '=' TBOOL ';'
3312 {
3313 ConfigFileEntry.short_motd = yylval.number;
3314 };
3315
3316 general_no_oper_flood: NO_OPER_FLOOD '=' TBOOL ';'
3317 {
3318 ConfigFileEntry.no_oper_flood = yylval.number;
3319 };
3320
3321 general_true_no_oper_flood: TRUE_NO_OPER_FLOOD '=' TBOOL ';'
3322 {
3323 ConfigFileEntry.true_no_oper_flood = yylval.number;
3324 };
3325
3326 general_oper_pass_resv: OPER_PASS_RESV '=' TBOOL ';'
3327 {
3328 ConfigFileEntry.oper_pass_resv = yylval.number;
3329 };
3330
3331 general_message_locale: MESSAGE_LOCALE '=' QSTRING ';'
3332 {
3333 if (ypass == 2)
3334 {
3335 if (strlen(yylval.string) > LOCALE_LENGTH-2)
3336 yylval.string[LOCALE_LENGTH-1] = '\0';
3337
3338 set_locale(yylval.string);
3339 }
3340 };
3341
3342 general_idletime: IDLETIME '=' timespec ';'
3343 {
3344 ConfigFileEntry.idletime = $3;
3345 };
3346
3347 general_dots_in_ident: DOTS_IN_IDENT '=' NUMBER ';'
3348 {
3349 ConfigFileEntry.dots_in_ident = $3;
3350 };
3351
3352 general_max_targets: MAX_TARGETS '=' NUMBER ';'
3353 {
3354 ConfigFileEntry.max_targets = $3;
3355 };
3356
3357 general_servlink_path: SERVLINK_PATH '=' QSTRING ';'
3358 {
3359 if (ypass == 2)
3360 {
3361 MyFree(ConfigFileEntry.servlink_path);
3362 DupString(ConfigFileEntry.servlink_path, yylval.string);
3363 }
3364 };
3365
3366 general_default_cipher_preference: DEFAULT_CIPHER_PREFERENCE '=' QSTRING ';'
3367 {
3368 #ifdef HAVE_LIBCRYPTO
3369 if (ypass == 2)
3370 {
3371 struct EncCapability *ecap;
3372 const char *cipher_name;
3373 int found = 0;
3374
3375 ConfigFileEntry.default_cipher_preference = NULL;
3376 cipher_name = yylval.string;
3377
3378 for (ecap = CipherTable; ecap->name; ecap++)
3379 {
3380 if ((irccmp(ecap->name, cipher_name) == 0) &&
3381 (ecap->cap & CAP_ENC_MASK))
3382 {
3383 ConfigFileEntry.default_cipher_preference = ecap;
3384 found = 1;
3385 break;
3386 }
3387 }
3388
3389 if (!found)
3390 yyerror("Invalid cipher");
3391 }
3392 #else
3393 if (ypass == 2)
3394 yyerror("Ignoring default_cipher_preference -- no OpenSSL support");
3395 #endif
3396 };
3397
3398 general_compression_level: COMPRESSION_LEVEL '=' NUMBER ';'
3399 {
3400 if (ypass == 2)
3401 {
3402 ConfigFileEntry.compression_level = $3;
3403 #ifndef HAVE_LIBZ
3404 yyerror("Ignoring compression_level -- no zlib support");
3405 #else
3406 if ((ConfigFileEntry.compression_level < 1) ||
3407 (ConfigFileEntry.compression_level > 9))
3408 {
3409 yyerror("Ignoring invalid compression_level, using default");
3410 ConfigFileEntry.compression_level = 0;
3411 }
3412 #endif
3413 }
3414 };
3415
3416 general_use_egd: USE_EGD '=' TBOOL ';'
3417 {
3418 ConfigFileEntry.use_egd = yylval.number;
3419 };
3420
3421 general_egdpool_path: EGDPOOL_PATH '=' QSTRING ';'
3422 {
3423 if (ypass == 2)
3424 {
3425 MyFree(ConfigFileEntry.egdpool_path);
3426 DupString(ConfigFileEntry.egdpool_path, yylval.string);
3427 }
3428 };
3429
3430 general_ping_cookie: PING_COOKIE '=' TBOOL ';'
3431 {
3432 ConfigFileEntry.ping_cookie = yylval.number;
3433 };
3434
3435 general_disable_auth: DISABLE_AUTH '=' TBOOL ';'
3436 {
3437 ConfigFileEntry.disable_auth = yylval.number;
3438 };
3439
3440 general_throttle_time: THROTTLE_TIME '=' timespec ';'
3441 {
3442 ConfigFileEntry.throttle_time = yylval.number;
3443 };
3444
3445 general_oper_umodes: OPER_UMODES
3446 {
3447 ConfigFileEntry.oper_umodes = 0;
3448 } '=' umode_oitems ';' ;
3449
3450 umode_oitems: umode_oitems ',' umode_oitem | umode_oitem;
3451 umode_oitem: T_BOTS
3452 {
3453 ConfigFileEntry.oper_umodes |= UMODE_BOTS;
3454 } | T_CCONN
3455 {
3456 ConfigFileEntry.oper_umodes |= UMODE_CCONN;
3457 } | T_DEAF
3458 {
3459 ConfigFileEntry.oper_umodes |= UMODE_DEAF;
3460 } | T_DEBUG
3461 {
3462 ConfigFileEntry.oper_umodes |= UMODE_DEBUG;
3463 } | T_FULL
3464 {
3465 ConfigFileEntry.oper_umodes |= UMODE_FULL;
3466 } | T_SKILL
3467 {
3468 ConfigFileEntry.oper_umodes |= UMODE_SKILL;
3469 } | T_NCHANGE
3470 {
3471 ConfigFileEntry.oper_umodes |= UMODE_NCHANGE;
3472 } | T_REJ
3473 {
3474 ConfigFileEntry.oper_umodes |= UMODE_REJ;
3475 } | T_UNAUTH
3476 {
3477 ConfigFileEntry.oper_umodes |= UMODE_UNAUTH;
3478 } | T_SPY
3479 {
3480 ConfigFileEntry.oper_umodes |= UMODE_SPY;
3481 } | T_EXTERNAL
3482 {
3483 ConfigFileEntry.oper_umodes |= UMODE_EXTERNAL;
3484 } | T_OPERWALL
3485 {
3486 ConfigFileEntry.oper_umodes |= UMODE_OPERWALL;
3487 } | T_SERVNOTICE
3488 {
3489 ConfigFileEntry.oper_umodes |= UMODE_SERVNOTICE;
3490 } | T_INVISIBLE
3491 {
3492 ConfigFileEntry.oper_umodes |= UMODE_INVISIBLE;
3493 } | T_WALLOP
3494 {
3495 ConfigFileEntry.oper_umodes |= UMODE_WALLOP;
3496 } | T_SOFTCALLERID
3497 {
3498 ConfigFileEntry.oper_umodes |= UMODE_SOFTCALLERID;
3499 } | T_CALLERID
3500 {
3501 ConfigFileEntry.oper_umodes |= UMODE_CALLERID;
3502 } | T_LOCOPS
3503 {
3504 ConfigFileEntry.oper_umodes |= UMODE_LOCOPS;
3505 };
3506
3507 general_oper_only_umodes: OPER_ONLY_UMODES
3508 {
3509 ConfigFileEntry.oper_only_umodes = 0;
3510 } '=' umode_items ';' ;
3511
3512 umode_items: umode_items ',' umode_item | umode_item;
3513 umode_item: T_BOTS
3514 {
3515 ConfigFileEntry.oper_only_umodes |= UMODE_BOTS;
3516 } | T_CCONN
3517 {
3518 ConfigFileEntry.oper_only_umodes |= UMODE_CCONN;
3519 } | T_DEAF
3520 {
3521 ConfigFileEntry.oper_only_umodes |= UMODE_DEAF;
3522 } | T_DEBUG
3523 {
3524 ConfigFileEntry.oper_only_umodes |= UMODE_DEBUG;
3525 } | T_FULL
3526 {
3527 ConfigFileEntry.oper_only_umodes |= UMODE_FULL;
3528 } | T_SKILL
3529 {
3530 ConfigFileEntry.oper_only_umodes |= UMODE_SKILL;
3531 } | T_NCHANGE
3532 {
3533 ConfigFileEntry.oper_only_umodes |= UMODE_NCHANGE;
3534 } | T_REJ
3535 {
3536 ConfigFileEntry.oper_only_umodes |= UMODE_REJ;
3537 } | T_UNAUTH
3538 {
3539 ConfigFileEntry.oper_only_umodes |= UMODE_UNAUTH;
3540 } | T_SPY
3541 {
3542 ConfigFileEntry.oper_only_umodes |= UMODE_SPY;
3543 } | T_EXTERNAL
3544 {
3545 ConfigFileEntry.oper_only_umodes |= UMODE_EXTERNAL;
3546 } | T_OPERWALL
3547 {
3548 ConfigFileEntry.oper_only_umodes |= UMODE_OPERWALL;
3549 } | T_SERVNOTICE
3550 {
3551 ConfigFileEntry.oper_only_umodes |= UMODE_SERVNOTICE;
3552 } | T_INVISIBLE
3553 {
3554 ConfigFileEntry.oper_only_umodes |= UMODE_INVISIBLE;
3555 } | T_WALLOP
3556 {
3557 ConfigFileEntry.oper_only_umodes |= UMODE_WALLOP;
3558 } | T_SOFTCALLERID
3559 {
3560 ConfigFileEntry.oper_only_umodes |= UMODE_SOFTCALLERID;
3561 } | T_CALLERID
3562 {
3563 ConfigFileEntry.oper_only_umodes |= UMODE_CALLERID;
3564 } | T_LOCOPS
3565 {
3566 ConfigFileEntry.oper_only_umodes |= UMODE_LOCOPS;
3567 };
3568
3569 general_min_nonwildcard: MIN_NONWILDCARD '=' NUMBER ';'
3570 {
3571 ConfigFileEntry.min_nonwildcard = $3;
3572 };
3573
3574 general_min_nonwildcard_simple: MIN_NONWILDCARD_SIMPLE '=' NUMBER ';'
3575 {
3576 ConfigFileEntry.min_nonwildcard_simple = $3;
3577 };
3578
3579 general_default_floodcount: DEFAULT_FLOODCOUNT '=' NUMBER ';'
3580 {
3581 ConfigFileEntry.default_floodcount = $3;
3582 };
3583
3584 general_client_flood: T_CLIENT_FLOOD '=' sizespec ';'
3585 {
3586 ConfigFileEntry.client_flood = $3;
3587 };
3588
3589 general_dot_in_ip6_addr: DOT_IN_IP6_ADDR '=' TBOOL ';'
3590 {
3591 ConfigFileEntry.dot_in_ip6_addr = yylval.number;
3592 };
3593
3594 /***************************************************************************
3595 * section glines
3596 ***************************************************************************/
3597 gline_entry: GLINES
3598 {
3599 if (ypass == 2)
3600 {
3601 yy_conf = make_conf_item(GDENY_TYPE);
3602 yy_aconf = map_to_conf(yy_conf);
3603 }
3604 } '{' gline_items '}' ';'
3605 {
3606 if (ypass == 2)
3607 {
3608 /*
3609 * since we re-allocate yy_conf/yy_aconf after the end of action=, at the
3610 * end we will have one extra, so we should free it.
3611 */
3612 if (yy_conf->name == NULL || yy_aconf->user == NULL)
3613 {
3614 delete_conf_item(yy_conf);
3615 yy_conf = NULL;
3616 yy_aconf = NULL;
3617 }
3618 }
3619 };
3620
3621 gline_items: gline_items gline_item | gline_item;
3622 gline_item: gline_enable |
3623 gline_duration |
3624 gline_logging |
3625 gline_user |
3626 gline_server |
3627 gline_action |
3628 error;
3629
3630 gline_enable: ENABLE '=' TBOOL ';'
3631 {
3632 if (ypass == 2)
3633 ConfigFileEntry.glines = yylval.number;
3634 };
3635
3636 gline_duration: DURATION '=' timespec ';'
3637 {
3638 if (ypass == 2)
3639 ConfigFileEntry.gline_time = $3;
3640 };
3641
3642 gline_logging: LOGGING
3643 {
3644 if (ypass == 2)
3645 ConfigFileEntry.gline_logging = 0;
3646 } '=' gline_logging_types ';';
3647 gline_logging_types: gline_logging_types ',' gline_logging_type_item | gline_logging_type_item;
3648 gline_logging_type_item: T_REJECT
3649 {
3650 if (ypass == 2)
3651 ConfigFileEntry.gline_logging |= GDENY_REJECT;
3652 } | T_BLOCK
3653 {
3654 if (ypass == 2)
3655 ConfigFileEntry.gline_logging |= GDENY_BLOCK;
3656 };
3657
3658 gline_user: USER '=' QSTRING ';'
3659 {
3660 if (ypass == 2)
3661 {
3662 struct CollectItem *yy_tmp = NULL;
3663
3664 if (yy_aconf->user == NULL)
3665 {
3666 split_nuh(yylval.string, NULL, &yy_aconf->user, &yy_aconf->host);
3667 }
3668 else
3669 {
3670 yy_tmp = MyMalloc(sizeof(struct CollectItem));
3671 split_nuh(yylval.string, NULL, &yy_tmp->user, &yy_tmp->host);
3672 dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
3673 }
3674 }
3675 };
3676
3677 gline_server: NAME '=' QSTRING ';'
3678 {
3679 if (ypass == 2)
3680 {
3681 MyFree(yy_conf->name);
3682 DupString(yy_conf->name, yylval.string);
3683 }
3684 };
3685
3686 gline_action: ACTION
3687 {
3688 if (ypass == 2)
3689 yy_aconf->flags = 0;
3690 } '=' gdeny_types ';'
3691 {
3692 if (ypass == 2)
3693 {
3694 struct CollectItem *yy_tmp = NULL;
3695 dlink_node *ptr, *next_ptr;
3696
3697 DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
3698 {
3699 struct AccessItem *new_aconf;
3700 struct ConfItem *new_conf;
3701
3702 yy_tmp = ptr->data;
3703 new_conf = make_conf_item(GDENY_TYPE);
3704 new_aconf = map_to_conf(new_conf);
3705
3706 new_aconf->flags = yy_aconf->flags;
3707
3708 if (yy_conf->name != NULL)
3709 DupString(new_conf->name, yy_conf->name);
3710 else
3711 DupString(new_conf->name, "*");
3712 if (yy_aconf->user != NULL)
3713 DupString(new_aconf->user, yy_tmp->user);
3714 else
3715 DupString(new_aconf->user, "*");
3716 if (yy_aconf->host != NULL)
3717 DupString(new_aconf->host, yy_tmp->host);
3718 else
3719 DupString(new_aconf->host, "*");
3720
3721 dlinkDelete(&yy_tmp->node, &col_conf_list);
3722 }
3723
3724 /*
3725 * In case someone has fed us with more than one action= after user/name
3726 * which would leak memory -Michael
3727 */
3728 if (yy_conf->name == NULL || yy_aconf->user == NULL)
3729 delete_conf_item(yy_conf);
3730
3731 yy_conf = make_conf_item(GDENY_TYPE);
3732 yy_aconf = map_to_conf(yy_conf);
3733 }
3734 };
3735
3736 gdeny_types: gdeny_types ',' gdeny_type_item | gdeny_type_item;
3737 gdeny_type_item: T_REJECT
3738 {
3739 if (ypass == 2)
3740 yy_aconf->flags |= GDENY_REJECT;
3741 } | T_BLOCK
3742 {
3743 if (ypass == 2)
3744 yy_aconf->flags |= GDENY_BLOCK;
3745 };
3746
3747 /***************************************************************************
3748 * section channel
3749 ***************************************************************************/
3750 channel_entry: CHANNEL
3751 '{' channel_items '}' ';';
3752
3753 channel_items: channel_items channel_item | channel_item;
3754 channel_item: channel_disable_local_channels | channel_use_except |
3755 channel_use_invex | channel_use_knock |
3756 channel_max_bans | channel_knock_delay |
3757 channel_knock_delay_channel | channel_max_chans_per_user |
3758 channel_quiet_on_ban | channel_default_split_user_count |
3759 channel_default_split_server_count |
3760 channel_no_create_on_split | channel_restrict_channels |
3761 channel_no_join_on_split | channel_burst_topicwho |
3762 channel_jflood_count | channel_jflood_time |
3763 error;
3764
3765 channel_restrict_channels: RESTRICT_CHANNELS '=' TBOOL ';'
3766 {
3767 ConfigChannel.restrict_channels = yylval.number;
3768 };
3769
3770 channel_disable_local_channels: DISABLE_LOCAL_CHANNELS '=' TBOOL ';'
3771 {
3772 ConfigChannel.disable_local_channels = yylval.number;
3773 };
3774
3775 channel_use_except: USE_EXCEPT '=' TBOOL ';'
3776 {
3777 ConfigChannel.use_except = yylval.number;
3778 };
3779
3780 channel_use_invex: USE_INVEX '=' TBOOL ';'
3781 {
3782 ConfigChannel.use_invex = yylval.number;
3783 };
3784
3785 channel_use_knock: USE_KNOCK '=' TBOOL ';'
3786 {
3787 ConfigChannel.use_knock = yylval.number;
3788 };
3789
3790 channel_knock_delay: KNOCK_DELAY '=' timespec ';'
3791 {
3792 ConfigChannel.knock_delay = $3;
3793 };
3794
3795 channel_knock_delay_channel: KNOCK_DELAY_CHANNEL '=' timespec ';'
3796 {
3797 ConfigChannel.knock_delay_channel = $3;
3798 };
3799
3800 channel_max_chans_per_user: MAX_CHANS_PER_USER '=' NUMBER ';'
3801 {
3802 ConfigChannel.max_chans_per_user = $3;
3803 };
3804
3805 channel_quiet_on_ban: QUIET_ON_BAN '=' TBOOL ';'
3806 {
3807 ConfigChannel.quiet_on_ban = yylval.number;
3808 };
3809
3810 channel_max_bans: MAX_BANS '=' NUMBER ';'
3811 {
3812 ConfigChannel.max_bans = $3;
3813 };
3814
3815 channel_default_split_user_count: DEFAULT_SPLIT_USER_COUNT '=' NUMBER ';'
3816 {
3817 ConfigChannel.default_split_user_count = $3;
3818 };
3819
3820 channel_default_split_server_count: DEFAULT_SPLIT_SERVER_COUNT '=' NUMBER ';'
3821 {
3822 ConfigChannel.default_split_server_count = $3;
3823 };
3824
3825 channel_no_create_on_split: NO_CREATE_ON_SPLIT '=' TBOOL ';'
3826 {
3827 ConfigChannel.no_create_on_split = yylval.number;
3828 };
3829
3830 channel_no_join_on_split: NO_JOIN_ON_SPLIT '=' TBOOL ';'
3831 {
3832 ConfigChannel.no_join_on_split = yylval.number;
3833 };
3834
3835 channel_burst_topicwho: BURST_TOPICWHO '=' TBOOL ';'
3836 {
3837 ConfigChannel.burst_topicwho = yylval.number;
3838 };
3839
3840 channel_jflood_count: JOIN_FLOOD_COUNT '=' NUMBER ';'
3841 {
3842 GlobalSetOptions.joinfloodcount = yylval.number;
3843 };
3844
3845 channel_jflood_time: JOIN_FLOOD_TIME '=' timespec ';'
3846 {
3847 GlobalSetOptions.joinfloodtime = yylval.number;
3848 };
3849
3850 /***************************************************************************
3851 * section serverhide
3852 ***************************************************************************/
3853 serverhide_entry: SERVERHIDE
3854 '{' serverhide_items '}' ';';
3855
3856 serverhide_items: serverhide_items serverhide_item | serverhide_item;
3857 serverhide_item: serverhide_flatten_links | serverhide_hide_servers |
3858 serverhide_links_delay |
3859 serverhide_disable_hidden |
3860 serverhide_hidden | serverhide_hidden_name |
3861 serverhide_hide_server_ips |
3862 error;
3863
3864 serverhide_flatten_links: FLATTEN_LINKS '=' TBOOL ';'
3865 {
3866 if (ypass == 2)
3867 ConfigServerHide.flatten_links = yylval.number;
3868 };
3869
3870 serverhide_hide_servers: HIDE_SERVERS '=' TBOOL ';'
3871 {
3872 if (ypass == 2)
3873 ConfigServerHide.hide_servers = yylval.number;
3874 };
3875
3876 serverhide_hidden_name: HIDDEN_NAME '=' QSTRING ';'
3877 {
3878 if (ypass == 2)
3879 {
3880 MyFree(ConfigServerHide.hidden_name);
3881 DupString(ConfigServerHide.hidden_name, yylval.string);
3882 }
3883 };
3884
3885 serverhide_links_delay: LINKS_DELAY '=' timespec ';'
3886 {
3887 if (ypass == 2)
3888 {
3889 if (($3 > 0) && ConfigServerHide.links_disabled == 1)
3890 {
3891 eventAddIsh("write_links_file", write_links_file, NULL, $3);
3892 ConfigServerHide.links_disabled = 0;
3893 }
3894
3895 ConfigServerHide.links_delay = $3;
3896 }
3897 };
3898
3899 serverhide_hidden: HIDDEN '=' TBOOL ';'
3900 {
3901 if (ypass == 2)
3902 ConfigServerHide.hidden = yylval.number;
3903 };
3904
3905 serverhide_disable_hidden: DISABLE_HIDDEN '=' TBOOL ';'
3906 {
3907 if (ypass == 2)
3908 ConfigServerHide.disable_hidden = yylval.number;
3909 };
3910
3911 serverhide_hide_server_ips: HIDE_SERVER_IPS '=' TBOOL ';'
3912 {
3913 if (ypass == 2)
3914 ConfigServerHide.hide_server_ips = yylval.number;
3915 };

Properties

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