/[svn]/ircd-hybrid/trunk/src/conf_parser.y
ViewVC logotype

Contents of /ircd-hybrid/trunk/src/conf_parser.y

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1647 - (show annotations)
Fri Nov 9 20:11:58 2012 UTC (8 years ago) by michael
File size: 70867 byte(s)
- Finish stabilizing/cleanup of conf parser

1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * conf_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 #include <string.h>
30
31 #include "config.h"
32 #include "stdinc.h"
33 #include "ircd.h"
34 #include "list.h"
35 #include "conf.h"
36 #include "conf_class.h"
37 #include "event.h"
38 #include "log.h"
39 #include "client.h" /* for UMODE_ALL only */
40 #include "irc_string.h"
41 #include "sprintf_irc.h"
42 #include "memory.h"
43 #include "modules.h"
44 #include "s_serv.h"
45 #include "hostmask.h"
46 #include "send.h"
47 #include "listener.h"
48 #include "resv.h"
49 #include "numeric.h"
50 #include "s_user.h"
51
52 #ifdef HAVE_LIBCRYPTO
53 #include <openssl/rsa.h>
54 #include <openssl/bio.h>
55 #include <openssl/pem.h>
56 #include <openssl/dh.h>
57 #endif
58
59 int yylex(void);
60
61 static struct
62 {
63 struct {
64 dlink_list list;
65 } mask,
66 leaf,
67 hub;
68
69 struct {
70 char buf[IRCD_BUFSIZE];
71 } name,
72 user,
73 host,
74 addr,
75 bind,
76 file,
77 ciph,
78 rpass,
79 spass,
80 class;
81
82 struct {
83 unsigned int value;
84 } flags,
85 modes,
86 size,
87 type,
88 port,
89 aftype,
90 ping_freq,
91 max_perip,
92 con_freq,
93 max_total,
94 max_global,
95 max_local,
96 max_ident,
97 max_sendq,
98 max_recvq,
99 cidr_bitlen_ipv4,
100 cidr_bitlen_ipv6,
101 number_per_cidr;
102 } block_state;
103
104 static void
105 reset_block_state(void)
106 {
107 dlink_node *ptr = NULL, *ptr_next = NULL;
108
109 DLINK_FOREACH_SAFE(ptr, ptr_next, block_state.mask.list.head)
110 {
111 MyFree(ptr->data);
112 dlinkDelete(ptr, &block_state.mask.list);
113 free_dlink_node(ptr);
114 }
115
116 DLINK_FOREACH_SAFE(ptr, ptr_next, block_state.leaf.list.head)
117 {
118 MyFree(ptr->data);
119 dlinkDelete(ptr, &block_state.leaf.list);
120 free_dlink_node(ptr);
121 }
122
123 DLINK_FOREACH_SAFE(ptr, ptr_next, block_state.hub.list.head)
124 {
125 MyFree(ptr->data);
126 dlinkDelete(ptr, &block_state.hub.list);
127 free_dlink_node(ptr);
128 }
129
130 memset(&block_state, 0, sizeof(block_state));
131 }
132
133 %}
134
135 %union {
136 int number;
137 char *string;
138 }
139
140 %token ACCEPT_PASSWORD
141 %token ADMIN
142 %token AFTYPE
143 %token ANTI_NICK_FLOOD
144 %token ANTI_SPAM_EXIT_MESSAGE_TIME
145 %token AUTOCONN
146 %token BYTES KBYTES MBYTES
147 %token CALLER_ID_WAIT
148 %token CAN_FLOOD
149 %token CHANNEL
150 %token CIDR_BITLEN_IPV4
151 %token CIDR_BITLEN_IPV6
152 %token CLASS
153 %token CONNECT
154 %token CONNECTFREQ
155 %token DEFAULT_FLOODCOUNT
156 %token DEFAULT_SPLIT_SERVER_COUNT
157 %token DEFAULT_SPLIT_USER_COUNT
158 %token DENY
159 %token DESCRIPTION
160 %token DIE
161 %token DISABLE_AUTH
162 %token DISABLE_FAKE_CHANNELS
163 %token DISABLE_REMOTE_COMMANDS
164 %token DOTS_IN_IDENT
165 %token EGDPOOL_PATH
166 %token EMAIL
167 %token ENCRYPTED
168 %token EXCEED_LIMIT
169 %token EXEMPT
170 %token FAILED_OPER_NOTICE
171 %token IRCD_FLAGS
172 %token FLATTEN_LINKS
173 %token GECOS
174 %token GENERAL
175 %token GLINE
176 %token GLINE_DURATION
177 %token GLINE_ENABLE
178 %token GLINE_EXEMPT
179 %token GLINE_REQUEST_DURATION
180 %token GLINE_MIN_CIDR
181 %token GLINE_MIN_CIDR6
182 %token GLOBAL_KILL
183 %token IRCD_AUTH
184 %token NEED_IDENT
185 %token HAVENT_READ_CONF
186 %token HIDDEN
187 %token HIDDEN_NAME
188 %token HIDE_SERVER_IPS
189 %token HIDE_SERVERS
190 %token HIDE_SPOOF_IPS
191 %token HOST
192 %token HUB
193 %token HUB_MASK
194 %token IGNORE_BOGUS_TS
195 %token INVISIBLE_ON_CONNECT
196 %token IP
197 %token KILL
198 %token KILL_CHASE_TIME_LIMIT
199 %token KLINE
200 %token KLINE_EXEMPT
201 %token KNOCK_DELAY
202 %token KNOCK_DELAY_CHANNEL
203 %token LEAF_MASK
204 %token LINKS_DELAY
205 %token LISTEN
206 %token T_LOG
207 %token MAX_ACCEPT
208 %token MAX_BANS
209 %token MAX_CHANS_PER_OPER
210 %token MAX_CHANS_PER_USER
211 %token MAX_GLOBAL
212 %token MAX_IDENT
213 %token MAX_LOCAL
214 %token MAX_NICK_CHANGES
215 %token MAX_NICK_TIME
216 %token MAX_NUMBER
217 %token MAX_TARGETS
218 %token MAX_WATCH
219 %token MESSAGE_LOCALE
220 %token MIN_NONWILDCARD
221 %token MIN_NONWILDCARD_SIMPLE
222 %token MODULE
223 %token MODULES
224 %token NAME
225 %token NEED_PASSWORD
226 %token NETWORK_DESC
227 %token NETWORK_NAME
228 %token NICK
229 %token NICK_CHANGES
230 %token NO_CREATE_ON_SPLIT
231 %token NO_JOIN_ON_SPLIT
232 %token NO_OPER_FLOOD
233 %token NO_TILDE
234 %token NUMBER
235 %token NUMBER_PER_CIDR
236 %token NUMBER_PER_IP
237 %token OPERATOR
238 %token OPERS_BYPASS_CALLERID
239 %token OPER_ONLY_UMODES
240 %token OPER_PASS_RESV
241 %token OPER_SPY_T
242 %token OPER_UMODES
243 %token JOIN_FLOOD_COUNT
244 %token JOIN_FLOOD_TIME
245 %token PACE_WAIT
246 %token PACE_WAIT_SIMPLE
247 %token PASSWORD
248 %token PATH
249 %token PING_COOKIE
250 %token PING_TIME
251 %token PORT
252 %token QSTRING
253 %token QUIET_ON_BAN
254 %token REASON
255 %token REDIRPORT
256 %token REDIRSERV
257 %token REGEX_T
258 %token REHASH
259 %token REMOTE
260 %token REMOTEBAN
261 %token RESTRICT_CHANNELS
262 %token RSA_PRIVATE_KEY_FILE
263 %token RSA_PUBLIC_KEY_FILE
264 %token SSL_CERTIFICATE_FILE
265 %token SSL_DH_PARAM_FILE
266 %token T_SSL_CLIENT_METHOD
267 %token T_SSL_SERVER_METHOD
268 %token T_SSLV3
269 %token T_TLSV1
270 %token RESV
271 %token RESV_EXEMPT
272 %token SECONDS MINUTES HOURS DAYS WEEKS
273 %token SENDQ
274 %token SEND_PASSWORD
275 %token SERVERHIDE
276 %token SERVERINFO
277 %token IRCD_SID
278 %token TKLINE_EXPIRE_NOTICES
279 %token T_SHARED
280 %token T_CLUSTER
281 %token TYPE
282 %token SHORT_MOTD
283 %token SPOOF
284 %token SPOOF_NOTICE
285 %token STATS_E_DISABLED
286 %token STATS_I_OPER_ONLY
287 %token STATS_K_OPER_ONLY
288 %token STATS_O_OPER_ONLY
289 %token STATS_P_OPER_ONLY
290 %token TBOOL
291 %token TMASKED
292 %token TS_MAX_DELTA
293 %token TS_WARN_DELTA
294 %token TWODOTS
295 %token T_ALL
296 %token T_BOTS
297 %token T_SOFTCALLERID
298 %token T_CALLERID
299 %token T_CCONN
300 %token T_CCONN_FULL
301 %token T_SSL_CIPHER_LIST
302 %token T_DEAF
303 %token T_DEBUG
304 %token T_DLINE
305 %token T_EXTERNAL
306 %token T_FULL
307 %token T_INVISIBLE
308 %token T_IPV4
309 %token T_IPV6
310 %token T_LOCOPS
311 %token T_MAX_CLIENTS
312 %token T_NCHANGE
313 %token T_OPERWALL
314 %token T_RECVQ
315 %token T_REJ
316 %token T_SERVER
317 %token T_SERVNOTICE
318 %token T_SET
319 %token T_SKILL
320 %token T_SPY
321 %token T_SSL
322 %token T_UMODES
323 %token T_UNAUTH
324 %token T_UNDLINE
325 %token T_UNLIMITED
326 %token T_UNRESV
327 %token T_UNXLINE
328 %token T_GLOBOPS
329 %token T_WALLOP
330 %token T_RESTART
331 %token T_SERVICE
332 %token T_SERVICES_NAME
333 %token THROTTLE_TIME
334 %token TRUE_NO_OPER_FLOOD
335 %token UNKLINE
336 %token USER
337 %token USE_EGD
338 %token USE_LOGGING
339 %token VHOST
340 %token VHOST6
341 %token XLINE
342 %token WARN_NO_NLINE
343 %token T_SIZE
344 %token T_FILE
345
346 %type <string> QSTRING
347 %type <number> NUMBER
348 %type <number> timespec
349 %type <number> timespec_
350 %type <number> sizespec
351 %type <number> sizespec_
352
353 %%
354 conf:
355 | conf conf_item
356 ;
357
358 conf_item: admin_entry
359 | logging_entry
360 | oper_entry
361 | channel_entry
362 | class_entry
363 | listen_entry
364 | auth_entry
365 | serverinfo_entry
366 | serverhide_entry
367 | resv_entry
368 | service_entry
369 | shared_entry
370 | cluster_entry
371 | connect_entry
372 | kill_entry
373 | deny_entry
374 | exempt_entry
375 | general_entry
376 | gecos_entry
377 | modules_entry
378 | error ';'
379 | error '}'
380 ;
381
382
383 timespec_: { $$ = 0; } | timespec;
384 timespec: NUMBER timespec_
385 {
386 $$ = $1 + $2;
387 }
388 | NUMBER SECONDS timespec_
389 {
390 $$ = $1 + $3;
391 }
392 | NUMBER MINUTES timespec_
393 {
394 $$ = $1 * 60 + $3;
395 }
396 | NUMBER HOURS timespec_
397 {
398 $$ = $1 * 60 * 60 + $3;
399 }
400 | NUMBER DAYS timespec_
401 {
402 $$ = $1 * 60 * 60 * 24 + $3;
403 }
404 | NUMBER WEEKS timespec_
405 {
406 $$ = $1 * 60 * 60 * 24 * 7 + $3;
407 }
408 ;
409
410 sizespec_: { $$ = 0; } | sizespec;
411 sizespec: NUMBER sizespec_ { $$ = $1 + $2; }
412 | NUMBER BYTES sizespec_ { $$ = $1 + $3; }
413 | NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; }
414 | NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
415 ;
416
417
418 /***************************************************************************
419 * section modules
420 ***************************************************************************/
421 modules_entry: MODULES
422 '{' modules_items '}' ';';
423
424 modules_items: modules_items modules_item | modules_item;
425 modules_item: modules_module | modules_path | error ';' ;
426
427 modules_module: MODULE '=' QSTRING ';'
428 {
429 if (conf_parser_ctx.pass == 2)
430 add_conf_module(libio_basename(yylval.string));
431 };
432
433 modules_path: PATH '=' QSTRING ';'
434 {
435 if (conf_parser_ctx.pass == 2)
436 mod_add_path(yylval.string);
437 };
438
439
440 serverinfo_entry: SERVERINFO '{' serverinfo_items '}' ';';
441
442 serverinfo_items: serverinfo_items serverinfo_item | serverinfo_item ;
443 serverinfo_item: serverinfo_name | serverinfo_vhost |
444 serverinfo_hub | serverinfo_description |
445 serverinfo_network_name | serverinfo_network_desc |
446 serverinfo_max_clients | serverinfo_ssl_dh_param_file |
447 serverinfo_rsa_private_key_file | serverinfo_vhost6 |
448 serverinfo_sid | serverinfo_ssl_certificate_file |
449 serverinfo_ssl_client_method | serverinfo_ssl_server_method |
450 serverinfo_ssl_cipher_list |
451 error ';' ;
452
453
454 serverinfo_ssl_client_method: T_SSL_CLIENT_METHOD '=' client_method_types ';' ;
455 serverinfo_ssl_server_method: T_SSL_SERVER_METHOD '=' server_method_types ';' ;
456
457 client_method_types: client_method_types ',' client_method_type_item | client_method_type_item;
458 client_method_type_item: T_SSLV3
459 {
460 #ifdef HAVE_LIBCRYPTO
461 if (conf_parser_ctx.pass == 2 && ServerInfo.client_ctx)
462 SSL_CTX_clear_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv3);
463 #endif
464 } | T_TLSV1
465 {
466 #ifdef HAVE_LIBCRYPTO
467 if (conf_parser_ctx.pass == 2 && ServerInfo.client_ctx)
468 SSL_CTX_clear_options(ServerInfo.client_ctx, SSL_OP_NO_TLSv1);
469 #endif
470 };
471
472 server_method_types: server_method_types ',' server_method_type_item | server_method_type_item;
473 server_method_type_item: T_SSLV3
474 {
475 #ifdef HAVE_LIBCRYPTO
476 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
477 SSL_CTX_clear_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv3);
478 #endif
479 } | T_TLSV1
480 {
481 #ifdef HAVE_LIBCRYPTO
482 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
483 SSL_CTX_clear_options(ServerInfo.server_ctx, SSL_OP_NO_TLSv1);
484 #endif
485 };
486
487 serverinfo_ssl_certificate_file: SSL_CERTIFICATE_FILE '=' QSTRING ';'
488 {
489 #ifdef HAVE_LIBCRYPTO
490 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
491 {
492 if (!ServerInfo.rsa_private_key_file)
493 {
494 yyerror("No rsa_private_key_file specified, SSL disabled");
495 break;
496 }
497
498 if (SSL_CTX_use_certificate_file(ServerInfo.server_ctx, yylval.string,
499 SSL_FILETYPE_PEM) <= 0 ||
500 SSL_CTX_use_certificate_file(ServerInfo.client_ctx, yylval.string,
501 SSL_FILETYPE_PEM) <= 0)
502 {
503 yyerror(ERR_lib_error_string(ERR_get_error()));
504 break;
505 }
506
507 if (SSL_CTX_use_PrivateKey_file(ServerInfo.server_ctx, ServerInfo.rsa_private_key_file,
508 SSL_FILETYPE_PEM) <= 0 ||
509 SSL_CTX_use_PrivateKey_file(ServerInfo.client_ctx, ServerInfo.rsa_private_key_file,
510 SSL_FILETYPE_PEM) <= 0)
511 {
512 yyerror(ERR_lib_error_string(ERR_get_error()));
513 break;
514 }
515
516 if (!SSL_CTX_check_private_key(ServerInfo.server_ctx) ||
517 !SSL_CTX_check_private_key(ServerInfo.client_ctx))
518 {
519 yyerror(ERR_lib_error_string(ERR_get_error()));
520 break;
521 }
522 }
523 #endif
524 };
525
526 serverinfo_rsa_private_key_file: RSA_PRIVATE_KEY_FILE '=' QSTRING ';'
527 {
528 #ifdef HAVE_LIBCRYPTO
529 if (conf_parser_ctx.pass == 1)
530 {
531 BIO *file;
532
533 if (ServerInfo.rsa_private_key)
534 {
535 RSA_free(ServerInfo.rsa_private_key);
536 ServerInfo.rsa_private_key = NULL;
537 }
538
539 if (ServerInfo.rsa_private_key_file)
540 {
541 MyFree(ServerInfo.rsa_private_key_file);
542 ServerInfo.rsa_private_key_file = NULL;
543 }
544
545 ServerInfo.rsa_private_key_file = xstrdup(yylval.string);
546
547 if ((file = BIO_new_file(yylval.string, "r")) == NULL)
548 {
549 yyerror("File open failed, ignoring");
550 break;
551 }
552
553 ServerInfo.rsa_private_key = PEM_read_bio_RSAPrivateKey(file, NULL, 0, NULL);
554
555 BIO_set_close(file, BIO_CLOSE);
556 BIO_free(file);
557
558 if (ServerInfo.rsa_private_key == NULL)
559 {
560 yyerror("Couldn't extract key, ignoring");
561 break;
562 }
563
564 if (!RSA_check_key(ServerInfo.rsa_private_key))
565 {
566 RSA_free(ServerInfo.rsa_private_key);
567 ServerInfo.rsa_private_key = NULL;
568
569 yyerror("Invalid key, ignoring");
570 break;
571 }
572
573 /* require 2048 bit (256 byte) key */
574 if (RSA_size(ServerInfo.rsa_private_key) != 256)
575 {
576 RSA_free(ServerInfo.rsa_private_key);
577 ServerInfo.rsa_private_key = NULL;
578
579 yyerror("Not a 2048 bit key, ignoring");
580 }
581 }
582 #endif
583 };
584
585 serverinfo_ssl_dh_param_file: SSL_DH_PARAM_FILE '=' QSTRING ';'
586 {
587 /* TBD - XXX: error reporting */
588 #ifdef HAVE_LIBCRYPTO
589 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
590 {
591 BIO *file = BIO_new_file(yylval.string, "r");
592
593 if (file)
594 {
595 DH *dh = PEM_read_bio_DHparams(file, NULL, NULL, NULL);
596
597 BIO_free(file);
598
599 if (dh)
600 {
601 if (DH_size(dh) < 128)
602 ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::ssl_dh_param_file -- need at least a 1024 bit DH prime size");
603 else
604 SSL_CTX_set_tmp_dh(ServerInfo.server_ctx, dh);
605
606 DH_free(dh);
607 }
608 }
609 }
610 #endif
611 };
612
613 serverinfo_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
614 {
615 #ifdef HAVE_LIBCRYPTO
616 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
617 SSL_CTX_set_cipher_list(ServerInfo.server_ctx, yylval.string);
618 #endif
619 };
620
621 serverinfo_name: NAME '=' QSTRING ';'
622 {
623 /* this isn't rehashable */
624 if (conf_parser_ctx.pass == 2 && !ServerInfo.name)
625 {
626 if (valid_servname(yylval.string))
627 ServerInfo.name = xstrdup(yylval.string);
628 else
629 {
630 ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::name -- invalid name. Aborting.");
631 exit(0);
632 }
633 }
634 };
635
636 serverinfo_sid: IRCD_SID '=' QSTRING ';'
637 {
638 /* this isn't rehashable */
639 if (conf_parser_ctx.pass == 2 && !ServerInfo.sid)
640 {
641 if (valid_sid(yylval.string))
642 ServerInfo.sid = xstrdup(yylval.string);
643 else
644 {
645 ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::sid -- invalid SID. Aborting.");
646 exit(0);
647 }
648 }
649 };
650
651 serverinfo_description: DESCRIPTION '=' QSTRING ';'
652 {
653 if (conf_parser_ctx.pass == 2)
654 {
655 MyFree(ServerInfo.description);
656 ServerInfo.description = xstrdup(yylval.string);
657 }
658 };
659
660 serverinfo_network_name: NETWORK_NAME '=' QSTRING ';'
661 {
662 if (conf_parser_ctx.pass == 2)
663 {
664 char *p;
665
666 if ((p = strchr(yylval.string, ' ')) != NULL)
667 p = '\0';
668
669 MyFree(ServerInfo.network_name);
670 ServerInfo.network_name = xstrdup(yylval.string);
671 }
672 };
673
674 serverinfo_network_desc: NETWORK_DESC '=' QSTRING ';'
675 {
676 if (conf_parser_ctx.pass == 2)
677 {
678 MyFree(ServerInfo.network_desc);
679 ServerInfo.network_desc = xstrdup(yylval.string);
680 }
681 };
682
683 serverinfo_vhost: VHOST '=' QSTRING ';'
684 {
685 if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
686 {
687 struct addrinfo hints, *res;
688
689 memset(&hints, 0, sizeof(hints));
690
691 hints.ai_family = AF_UNSPEC;
692 hints.ai_socktype = SOCK_STREAM;
693 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
694
695 if (getaddrinfo(yylval.string, NULL, &hints, &res))
696 ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
697 else
698 {
699 assert(res != NULL);
700
701 memcpy(&ServerInfo.ip, res->ai_addr, res->ai_addrlen);
702 ServerInfo.ip.ss.ss_family = res->ai_family;
703 ServerInfo.ip.ss_len = res->ai_addrlen;
704 freeaddrinfo(res);
705
706 ServerInfo.specific_ipv4_vhost = 1;
707 }
708 }
709 };
710
711 serverinfo_vhost6: VHOST6 '=' QSTRING ';'
712 {
713 #ifdef IPV6
714 if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
715 {
716 struct addrinfo hints, *res;
717
718 memset(&hints, 0, sizeof(hints));
719
720 hints.ai_family = AF_UNSPEC;
721 hints.ai_socktype = SOCK_STREAM;
722 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
723
724 if (getaddrinfo(yylval.string, NULL, &hints, &res))
725 ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost6(%s)", yylval.string);
726 else
727 {
728 assert(res != NULL);
729
730 memcpy(&ServerInfo.ip6, res->ai_addr, res->ai_addrlen);
731 ServerInfo.ip6.ss.ss_family = res->ai_family;
732 ServerInfo.ip6.ss_len = res->ai_addrlen;
733 freeaddrinfo(res);
734
735 ServerInfo.specific_ipv6_vhost = 1;
736 }
737 }
738 #endif
739 };
740
741 serverinfo_max_clients: T_MAX_CLIENTS '=' NUMBER ';'
742 {
743 if (conf_parser_ctx.pass == 2)
744 {
745 recalc_fdlimit(NULL);
746
747 if ($3 < MAXCLIENTS_MIN)
748 {
749 char buf[IRCD_BUFSIZE];
750 ircsprintf(buf, "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
751 yyerror(buf);
752 }
753 else if ($3 > MAXCLIENTS_MAX)
754 {
755 char buf[IRCD_BUFSIZE];
756 ircsprintf(buf, "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
757 yyerror(buf);
758 }
759 else
760 ServerInfo.max_clients = $3;
761 }
762 };
763
764 serverinfo_hub: HUB '=' TBOOL ';'
765 {
766 if (conf_parser_ctx.pass == 2)
767 ServerInfo.hub = yylval.number;
768 };
769
770 /***************************************************************************
771 * admin section
772 ***************************************************************************/
773 admin_entry: ADMIN '{' admin_items '}' ';' ;
774
775 admin_items: admin_items admin_item | admin_item;
776 admin_item: admin_name | admin_description |
777 admin_email | error ';' ;
778
779 admin_name: NAME '=' QSTRING ';'
780 {
781 if (conf_parser_ctx.pass == 2)
782 {
783 MyFree(AdminInfo.name);
784 AdminInfo.name = xstrdup(yylval.string);
785 }
786 };
787
788 admin_email: EMAIL '=' QSTRING ';'
789 {
790 if (conf_parser_ctx.pass == 2)
791 {
792 MyFree(AdminInfo.email);
793 AdminInfo.email = xstrdup(yylval.string);
794 }
795 };
796
797 admin_description: DESCRIPTION '=' QSTRING ';'
798 {
799 if (conf_parser_ctx.pass == 2)
800 {
801 MyFree(AdminInfo.description);
802 AdminInfo.description = xstrdup(yylval.string);
803 }
804 };
805
806 /***************************************************************************
807 * section logging
808 ***************************************************************************/
809 logging_entry: T_LOG '{' logging_items '}' ';' ;
810 logging_items: logging_items logging_item | logging_item ;
811
812 logging_item: logging_use_logging | logging_file_entry |
813 error ';' ;
814
815 logging_use_logging: USE_LOGGING '=' TBOOL ';'
816 {
817 if (conf_parser_ctx.pass == 2)
818 ConfigLoggingEntry.use_logging = yylval.number;
819 };
820
821 logging_file_entry:
822 {
823 if (conf_parser_ctx.pass == 2)
824 reset_block_state();
825 } T_FILE '{' logging_file_items '}' ';'
826 {
827 if (conf_parser_ctx.pass != 2)
828 break;
829
830 if (block_state.type.value && block_state.file.buf[0])
831 log_add_file(block_state.type.value, block_state.size.value,
832 block_state.file.buf);
833 };
834
835 logging_file_items: logging_file_items logging_file_item |
836 logging_file_item ;
837
838 logging_file_item: logging_file_name | logging_file_type |
839 logging_file_size | error ';' ;
840
841 logging_file_name: NAME '=' QSTRING ';'
842 {
843 if (conf_parser_ctx.pass != 2)
844 break;
845
846 strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
847 }
848
849 logging_file_size: T_SIZE '=' sizespec ';'
850 {
851 block_state.size.value = $3;
852 } | T_SIZE '=' T_UNLIMITED ';'
853 {
854 block_state.size.value = 0;
855 };
856
857 logging_file_type: TYPE
858 {
859 if (conf_parser_ctx.pass == 2)
860 block_state.type.value = 0;
861 } '=' logging_file_type_items ';' ;
862
863 logging_file_type_items: logging_file_type_items ',' logging_file_type_item | logging_file_type_item;
864 logging_file_type_item: USER
865 {
866 if (conf_parser_ctx.pass == 2)
867 block_state.type.value = LOG_TYPE_USER;
868 } | OPERATOR
869 {
870 if (conf_parser_ctx.pass == 2)
871 block_state.type.value = LOG_TYPE_OPER;
872 } | GLINE
873 {
874 if (conf_parser_ctx.pass == 2)
875 block_state.type.value = LOG_TYPE_GLINE;
876 } | T_DLINE
877 {
878 if (conf_parser_ctx.pass == 2)
879 block_state.type.value = LOG_TYPE_DLINE;
880 } | KLINE
881 {
882 if (conf_parser_ctx.pass == 2)
883 block_state.type.value = LOG_TYPE_KLINE;
884 } | KILL
885 {
886 if (conf_parser_ctx.pass == 2)
887 block_state.type.value = LOG_TYPE_KILL;
888 } | T_DEBUG
889 {
890 if (conf_parser_ctx.pass == 2)
891 block_state.type.value = LOG_TYPE_DEBUG;
892 };
893
894
895 /***************************************************************************
896 * section oper
897 ***************************************************************************/
898 oper_entry: OPERATOR
899 {
900 if (conf_parser_ctx.pass != 2)
901 break;
902
903 reset_block_state();
904 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
905 } '{' oper_items '}' ';'
906 {
907 dlink_node *ptr = NULL;
908
909 if (conf_parser_ctx.pass != 2)
910 break;
911
912 if (!block_state.name.buf[0])
913 break;
914 #ifdef HAVE_LIBCRYPTO
915 if (!(block_state.file.buf[0] ||
916 block_state.rpass.buf[0]))
917 break;
918 #else
919 if (!block_state.rpass.buf[0])
920 break;
921 #endif
922
923 DLINK_FOREACH(ptr, block_state.mask.list.head)
924 {
925 struct MaskItem *conf = NULL;
926 struct split_nuh_item nuh;
927
928 nuh.nuhmask = ptr->data;
929 nuh.nickptr = NULL;
930 nuh.userptr = block_state.user.buf;
931 nuh.hostptr = block_state.host.buf;
932 nuh.nicksize = 0;
933 nuh.usersize = sizeof(block_state.user.buf);
934 nuh.hostsize = sizeof(block_state.host.buf);
935 split_nuh(&nuh);
936
937 conf = conf_make(CONF_OPER);
938 conf->user = xstrdup(block_state.user.buf);
939 conf->host = xstrdup(block_state.host.buf);
940
941 if (block_state.rpass.buf[0])
942 conf->passwd = xstrdup(block_state.rpass.buf);
943
944 conf->flags = block_state.flags.value;
945 conf->modes = block_state.modes.value;
946 conf->port = block_state.port.value;
947 conf->htype = parse_netmask(conf->host, &conf->addr, &conf->bits);
948
949 conf_add_class_to_conf(conf, block_state.class.buf);
950
951 #ifdef HAVE_LIBCRYPTO
952 if (block_state.file.buf[0])
953 {
954 BIO *file = NULL;
955 RSA *pkey = NULL;
956
957 if ((file = BIO_new_file(block_state.file.buf, "r")) == NULL)
958 {
959 yyerror("Ignoring rsa_public_key_file -- file doesn't exist");
960 break;
961 }
962
963 if ((pkey = PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL)) == NULL)
964 {
965 yyerror("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
966 break;
967 }
968
969 conf->rsa_public_key = pkey;
970 BIO_set_close(file, BIO_CLOSE);
971 BIO_free(file);
972 }
973 #endif /* HAVE_LIBCRYPTO */
974 }
975 };
976
977 oper_items: oper_items oper_item | oper_item;
978 oper_item: oper_name | oper_user | oper_password |
979 oper_umodes | oper_class | oper_encrypted |
980 oper_rsa_public_key_file | oper_flags | error ';' ;
981
982 oper_name: NAME '=' QSTRING ';'
983 {
984 if (conf_parser_ctx.pass == 2)
985 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
986 };
987
988 oper_user: USER '=' QSTRING ';'
989 {
990 if (conf_parser_ctx.pass == 2)
991 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
992 };
993
994 oper_password: PASSWORD '=' QSTRING ';'
995 {
996 if (conf_parser_ctx.pass == 2)
997 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
998 };
999
1000 oper_encrypted: ENCRYPTED '=' TBOOL ';'
1001 {
1002 if (conf_parser_ctx.pass == 2)
1003 {
1004 if (yylval.number)
1005 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
1006 else
1007 block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
1008 }
1009 };
1010
1011 oper_rsa_public_key_file: RSA_PUBLIC_KEY_FILE '=' QSTRING ';'
1012 {
1013 if (conf_parser_ctx.pass == 2)
1014 strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
1015 };
1016
1017 oper_class: CLASS '=' QSTRING ';'
1018 {
1019 if (conf_parser_ctx.pass == 2)
1020 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
1021 };
1022
1023 oper_umodes: T_UMODES
1024 {
1025 if (conf_parser_ctx.pass == 2)
1026 block_state.modes.value = 0;
1027 } '=' oper_umodes_items ';' ;
1028
1029 oper_umodes_items: oper_umodes_items ',' oper_umodes_item | oper_umodes_item;
1030 oper_umodes_item: T_BOTS
1031 {
1032 if (conf_parser_ctx.pass == 2)
1033 block_state.modes.value |= UMODE_BOTS;
1034 } | T_CCONN
1035 {
1036 if (conf_parser_ctx.pass == 2)
1037 block_state.modes.value |= UMODE_CCONN;
1038 } | T_CCONN_FULL
1039 {
1040 if (conf_parser_ctx.pass == 2)
1041 block_state.modes.value |= UMODE_CCONN_FULL;
1042 } | T_DEAF
1043 {
1044 if (conf_parser_ctx.pass == 2)
1045 block_state.modes.value |= UMODE_DEAF;
1046 } | T_DEBUG
1047 {
1048 if (conf_parser_ctx.pass == 2)
1049 block_state.modes.value |= UMODE_DEBUG;
1050 } | T_FULL
1051 {
1052 if (conf_parser_ctx.pass == 2)
1053 block_state.modes.value |= UMODE_FULL;
1054 } | HIDDEN
1055 {
1056 if (conf_parser_ctx.pass == 2)
1057 block_state.modes.value |= UMODE_HIDDEN;
1058 } | T_SKILL
1059 {
1060 if (conf_parser_ctx.pass == 2)
1061 block_state.modes.value |= UMODE_SKILL;
1062 } | T_NCHANGE
1063 {
1064 if (conf_parser_ctx.pass == 2)
1065 block_state.modes.value |= UMODE_NCHANGE;
1066 } | T_REJ
1067 {
1068 if (conf_parser_ctx.pass == 2)
1069 block_state.modes.value |= UMODE_REJ;
1070 } | T_UNAUTH
1071 {
1072 if (conf_parser_ctx.pass == 2)
1073 block_state.modes.value |= UMODE_UNAUTH;
1074 } | T_SPY
1075 {
1076 if (conf_parser_ctx.pass == 2)
1077 block_state.modes.value |= UMODE_SPY;
1078 } | T_EXTERNAL
1079 {
1080 if (conf_parser_ctx.pass == 2)
1081 block_state.modes.value |= UMODE_EXTERNAL;
1082 } | T_OPERWALL
1083 {
1084 if (conf_parser_ctx.pass == 2)
1085 block_state.modes.value |= UMODE_OPERWALL;
1086 } | T_SERVNOTICE
1087 {
1088 if (conf_parser_ctx.pass == 2)
1089 block_state.modes.value |= UMODE_SERVNOTICE;
1090 } | T_INVISIBLE
1091 {
1092 if (conf_parser_ctx.pass == 2)
1093 block_state.modes.value |= UMODE_INVISIBLE;
1094 } | T_WALLOP
1095 {
1096 if (conf_parser_ctx.pass == 2)
1097 block_state.modes.value |= UMODE_WALLOP;
1098 } | T_SOFTCALLERID
1099 {
1100 if (conf_parser_ctx.pass == 2)
1101 block_state.modes.value |= UMODE_SOFTCALLERID;
1102 } | T_CALLERID
1103 {
1104 if (conf_parser_ctx.pass == 2)
1105 block_state.modes.value |= UMODE_CALLERID;
1106 } | T_LOCOPS
1107 {
1108 if (conf_parser_ctx.pass == 2)
1109 block_state.modes.value |= UMODE_LOCOPS;
1110 };
1111
1112 oper_flags: IRCD_FLAGS
1113 {
1114 if (conf_parser_ctx.pass == 2)
1115 block_state.port.value = 0;
1116 } '=' oper_flags_items ';';
1117
1118 oper_flags_items: oper_flags_items ',' oper_flags_item | oper_flags_item;
1119 oper_flags_item: GLOBAL_KILL
1120 {
1121 if (conf_parser_ctx.pass == 2)
1122 block_state.port.value |= OPER_FLAG_GLOBAL_KILL;
1123 } | REMOTE
1124 {
1125 if (conf_parser_ctx.pass == 2)
1126 block_state.port.value |= OPER_FLAG_REMOTE;
1127 } | KLINE
1128 {
1129 if (conf_parser_ctx.pass == 2)
1130 block_state.port.value |= OPER_FLAG_K;
1131 } | UNKLINE
1132 {
1133 if (conf_parser_ctx.pass == 2)
1134 block_state.port.value |= OPER_FLAG_UNKLINE;
1135 } | T_DLINE
1136 {
1137 if (conf_parser_ctx.pass == 2)
1138 block_state.port.value |= OPER_FLAG_DLINE;
1139 } | T_UNDLINE
1140 {
1141 if (conf_parser_ctx.pass == 2)
1142 block_state.port.value |= OPER_FLAG_UNDLINE;
1143 } | XLINE
1144 {
1145 if (conf_parser_ctx.pass == 2)
1146 block_state.port.value |= OPER_FLAG_X;
1147 } | GLINE
1148 {
1149 if (conf_parser_ctx.pass == 2)
1150 block_state.port.value |= OPER_FLAG_GLINE;
1151 } | DIE
1152 {
1153 if (conf_parser_ctx.pass == 2)
1154 block_state.port.value |= OPER_FLAG_DIE;
1155 } | T_RESTART
1156 {
1157 if (conf_parser_ctx.pass == 2)
1158 block_state.port.value |= OPER_FLAG_RESTART;
1159 } | REHASH
1160 {
1161 if (conf_parser_ctx.pass == 2)
1162 block_state.port.value |= OPER_FLAG_REHASH;
1163 } | ADMIN
1164 {
1165 if (conf_parser_ctx.pass == 2)
1166 block_state.port.value |= OPER_FLAG_ADMIN;
1167 } | NICK_CHANGES
1168 {
1169 if (conf_parser_ctx.pass == 2)
1170 block_state.port.value |= OPER_FLAG_N;
1171 } | T_OPERWALL
1172 {
1173 if (conf_parser_ctx.pass == 2)
1174 block_state.port.value |= OPER_FLAG_OPERWALL;
1175 } | T_GLOBOPS
1176 {
1177 if (conf_parser_ctx.pass == 2)
1178 block_state.port.value |= OPER_FLAG_GLOBOPS;
1179 } | OPER_SPY_T
1180 {
1181 if (conf_parser_ctx.pass == 2)
1182 block_state.port.value |= OPER_FLAG_OPER_SPY;
1183 } | REMOTEBAN
1184 {
1185 if (conf_parser_ctx.pass == 2)
1186 block_state.port.value |= OPER_FLAG_REMOTEBAN;
1187 } | T_SET
1188 {
1189 if (conf_parser_ctx.pass == 2)
1190 block_state.port.value |= OPER_FLAG_SET;
1191 } | MODULE
1192 {
1193 if (conf_parser_ctx.pass == 2)
1194 block_state.port.value |= OPER_FLAG_MODULE;
1195 };
1196
1197
1198 /***************************************************************************
1199 * section class
1200 ***************************************************************************/
1201 class_entry: CLASS
1202 {
1203 if (conf_parser_ctx.pass == 1)
1204 reset_block_state();
1205 } '{' class_items '}' ';'
1206 {
1207 struct ClassItem *class = NULL;
1208
1209 if (conf_parser_ctx.pass != 1)
1210 break;
1211
1212 if (!block_state.class.buf[0])
1213 break;
1214
1215 if (!(class = class_find(block_state.class.buf, 0)))
1216 class = class_make();
1217
1218 class->active = 1;
1219 MyFree(class->name);
1220 class->name = xstrdup(block_state.class.buf);
1221 class->ping_freq = block_state.ping_freq.value;
1222 class->max_perip = block_state.max_perip.value;
1223 class->con_freq = block_state.con_freq.value;
1224 class->max_total = block_state.max_total.value;
1225 class->max_global = block_state.max_global.value;
1226 class->max_local = block_state.max_local.value;
1227 class->max_ident = block_state.max_ident.value;
1228 class->max_sendq = block_state.max_sendq.value;
1229 class->max_recvq = block_state.max_recvq.value;
1230
1231 if (class->number_per_cidr && block_state.number_per_cidr.value)
1232 if ((class->cidr_bitlen_ipv4 && block_state.cidr_bitlen_ipv4.value) ||
1233 (class->cidr_bitlen_ipv6 && block_state.cidr_bitlen_ipv6.value))
1234 if ((class->cidr_bitlen_ipv4 != block_state.cidr_bitlen_ipv4.value) ||
1235 (class->cidr_bitlen_ipv6 != block_state.cidr_bitlen_ipv6.value))
1236 rebuild_cidr_list(class);
1237
1238 class->cidr_bitlen_ipv4 = block_state.cidr_bitlen_ipv4.value;
1239 class->cidr_bitlen_ipv6 = block_state.cidr_bitlen_ipv6.value;
1240 class->number_per_cidr = block_state.number_per_cidr.value;
1241 };
1242
1243 class_items: class_items class_item | class_item;
1244 class_item: class_name |
1245 class_cidr_bitlen_ipv4 | class_cidr_bitlen_ipv6 |
1246 class_ping_time |
1247 class_number_per_cidr |
1248 class_number_per_ip |
1249 class_connectfreq |
1250 class_max_number |
1251 class_max_global |
1252 class_max_local |
1253 class_max_ident |
1254 class_sendq | class_recvq |
1255 error ';' ;
1256
1257 class_name: NAME '=' QSTRING ';'
1258 {
1259 if (conf_parser_ctx.pass == 1)
1260 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
1261 };
1262
1263 class_ping_time: PING_TIME '=' timespec ';'
1264 {
1265 if (conf_parser_ctx.pass == 1)
1266 block_state.ping_freq.value = $3;
1267 };
1268
1269 class_number_per_ip: NUMBER_PER_IP '=' NUMBER ';'
1270 {
1271 if (conf_parser_ctx.pass == 1)
1272 block_state.max_perip.value = $3;
1273 };
1274
1275 class_connectfreq: CONNECTFREQ '=' timespec ';'
1276 {
1277 if (conf_parser_ctx.pass == 1)
1278 block_state.con_freq.value = $3;
1279 };
1280
1281 class_max_number: MAX_NUMBER '=' NUMBER ';'
1282 {
1283 if (conf_parser_ctx.pass == 1)
1284 block_state.max_total.value = $3;
1285 };
1286
1287 class_max_global: MAX_GLOBAL '=' NUMBER ';'
1288 {
1289 if (conf_parser_ctx.pass == 1)
1290 block_state.max_global.value = $3;
1291 };
1292
1293 class_max_local: MAX_LOCAL '=' NUMBER ';'
1294 {
1295 if (conf_parser_ctx.pass == 1)
1296 block_state.max_local.value = $3;
1297 };
1298
1299 class_max_ident: MAX_IDENT '=' NUMBER ';'
1300 {
1301 if (conf_parser_ctx.pass == 1)
1302 block_state.max_ident.value = $3;
1303 };
1304
1305 class_sendq: SENDQ '=' sizespec ';'
1306 {
1307 if (conf_parser_ctx.pass == 1)
1308 block_state.max_sendq.value = $3;
1309 };
1310
1311 class_recvq: T_RECVQ '=' sizespec ';'
1312 {
1313 if (conf_parser_ctx.pass == 1)
1314 if ($3 >= CLIENT_FLOOD_MIN && $3 <= CLIENT_FLOOD_MAX)
1315 block_state.max_recvq.value = $3;
1316 };
1317
1318 class_cidr_bitlen_ipv4: CIDR_BITLEN_IPV4 '=' NUMBER ';'
1319 {
1320 if (conf_parser_ctx.pass == 1)
1321 block_state.cidr_bitlen_ipv4.value = $3 > 32 ? 32 : $3;
1322 };
1323
1324 class_cidr_bitlen_ipv6: CIDR_BITLEN_IPV6 '=' NUMBER ';'
1325 {
1326 if (conf_parser_ctx.pass == 1)
1327 block_state.cidr_bitlen_ipv6.value = $3 > 128 ? 128 : $3;
1328 };
1329
1330 class_number_per_cidr: NUMBER_PER_CIDR '=' NUMBER ';'
1331 {
1332 if (conf_parser_ctx.pass == 1)
1333 block_state.number_per_cidr.value = $3;
1334 };
1335
1336 /***************************************************************************
1337 * section listen
1338 ***************************************************************************/
1339 listen_entry: LISTEN
1340 {
1341 if (conf_parser_ctx.pass == 2)
1342 reset_block_state();
1343 } '{' listen_items '}' ';';
1344
1345 listen_flags: IRCD_FLAGS
1346 {
1347 block_state.flags.value = 0;
1348 } '=' listen_flags_items ';';
1349
1350 listen_flags_items: listen_flags_items ',' listen_flags_item | listen_flags_item;
1351 listen_flags_item: T_SSL
1352 {
1353 if (conf_parser_ctx.pass == 2)
1354 block_state.flags.value |= LISTENER_SSL;
1355 } | HIDDEN
1356 {
1357 if (conf_parser_ctx.pass == 2)
1358 block_state.flags.value |= LISTENER_HIDDEN;
1359 } | T_SERVER
1360 {
1361 if (conf_parser_ctx.pass == 2)
1362 block_state.flags.value |= LISTENER_SERVER;
1363 };
1364
1365 listen_items: listen_items listen_item | listen_item;
1366 listen_item: listen_port | listen_flags | listen_address | listen_host | error ';';
1367
1368 listen_port: PORT '=' port_items { block_state.flags.value |= 0; } ';';
1369
1370 port_items: port_items ',' port_item | port_item;
1371
1372 port_item: NUMBER
1373 {
1374 if (conf_parser_ctx.pass == 2)
1375 {
1376 if (block_state.flags.value & LISTENER_SSL)
1377 #ifdef HAVE_LIBCRYPTO
1378 if (!ServerInfo.server_ctx)
1379 #endif
1380 {
1381 yyerror("SSL not available - port closed");
1382 break;
1383 }
1384 add_listener($1, block_state.addr.buf, block_state.flags.value);
1385 }
1386 } | NUMBER TWODOTS NUMBER
1387 {
1388 if (conf_parser_ctx.pass == 2)
1389 {
1390 int i;
1391
1392 if (block_state.flags.value & LISTENER_SSL)
1393 #ifdef HAVE_LIBCRYPTO
1394 if (!ServerInfo.server_ctx)
1395 #endif
1396 {
1397 yyerror("SSL not available - port closed");
1398 break;
1399 }
1400
1401 for (i = $1; i <= $3; ++i)
1402 add_listener(i, block_state.addr.buf, block_state.flags.value);
1403 }
1404 };
1405
1406 listen_address: IP '=' QSTRING ';'
1407 {
1408 if (conf_parser_ctx.pass == 2)
1409 strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
1410 };
1411
1412 listen_host: HOST '=' QSTRING ';'
1413 {
1414 if (conf_parser_ctx.pass == 2)
1415 strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
1416 };
1417
1418 /***************************************************************************
1419 * section auth
1420 ***************************************************************************/
1421 auth_entry: IRCD_AUTH
1422 {
1423 if (conf_parser_ctx.pass == 2)
1424 reset_block_state();
1425 } '{' auth_items '}' ';'
1426 {
1427 dlink_node *ptr = NULL;
1428
1429 if (conf_parser_ctx.pass != 2)
1430 break;
1431
1432 DLINK_FOREACH(ptr, block_state.mask.list.head)
1433 {
1434 struct MaskItem *conf = NULL;
1435 struct split_nuh_item nuh;
1436
1437 nuh.nuhmask = ptr->data;
1438 nuh.nickptr = NULL;
1439 nuh.userptr = block_state.user.buf;
1440 nuh.hostptr = block_state.host.buf;
1441 nuh.nicksize = 0;
1442 nuh.usersize = sizeof(block_state.user.buf);
1443 nuh.hostsize = sizeof(block_state.host.buf);
1444 split_nuh(&nuh);
1445
1446 conf = conf_make(CONF_CLIENT);
1447 conf->user = xstrdup(collapse(block_state.user.buf));
1448 conf->host = xstrdup(collapse(block_state.host.buf));
1449
1450 if (block_state.rpass.buf[0])
1451 conf->passwd = xstrdup(block_state.rpass.buf);
1452 if (block_state.name.buf[0])
1453 conf->passwd = xstrdup(block_state.name.buf);
1454
1455 conf->flags = block_state.flags.value;
1456 conf->port = block_state.port.value;
1457
1458 conf_add_class_to_conf(conf, block_state.class.buf);
1459 add_conf_by_address(CONF_CLIENT, conf);
1460 }
1461 };
1462
1463 auth_items: auth_items auth_item | auth_item;
1464 auth_item: auth_user | auth_passwd | auth_class | auth_flags |
1465 auth_spoof | auth_redir_serv | auth_redir_port |
1466 auth_encrypted | error ';' ;
1467
1468 auth_user: USER '=' QSTRING ';'
1469 {
1470 if (conf_parser_ctx.pass == 2)
1471 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
1472 };
1473
1474 auth_passwd: PASSWORD '=' QSTRING ';'
1475 {
1476 if (conf_parser_ctx.pass == 2)
1477 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
1478 };
1479
1480 auth_class: CLASS '=' QSTRING ';'
1481 {
1482 if (conf_parser_ctx.pass == 2)
1483 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
1484 };
1485
1486 auth_encrypted: ENCRYPTED '=' TBOOL ';'
1487 {
1488 if (conf_parser_ctx.pass == 2)
1489 {
1490 if (yylval.number)
1491 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
1492 else
1493 block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
1494 }
1495 };
1496
1497 auth_flags: IRCD_FLAGS
1498 {
1499 if (conf_parser_ctx.pass == 2)
1500 block_state.flags.value = 0;
1501 } '=' auth_flags_items ';';
1502
1503 auth_flags_items: auth_flags_items ',' auth_flags_item | auth_flags_item;
1504 auth_flags_item: SPOOF_NOTICE
1505 {
1506 if (conf_parser_ctx.pass == 2)
1507 block_state.flags.value |= CONF_FLAGS_SPOOF_NOTICE;
1508 } | EXCEED_LIMIT
1509 {
1510 if (conf_parser_ctx.pass == 2)
1511 block_state.flags.value |= CONF_FLAGS_NOLIMIT;
1512 } | KLINE_EXEMPT
1513 {
1514 if (conf_parser_ctx.pass == 2)
1515 block_state.flags.value |= CONF_FLAGS_EXEMPTKLINE;
1516 } | NEED_IDENT
1517 {
1518 if (conf_parser_ctx.pass == 2)
1519 block_state.flags.value |= CONF_FLAGS_NEED_IDENTD;
1520 } | CAN_FLOOD
1521 {
1522 if (conf_parser_ctx.pass == 2)
1523 block_state.flags.value |= CONF_FLAGS_CAN_FLOOD;
1524 } | NO_TILDE
1525 {
1526 if (conf_parser_ctx.pass == 2)
1527 block_state.flags.value |= CONF_FLAGS_NO_TILDE;
1528 } | GLINE_EXEMPT
1529 {
1530 if (conf_parser_ctx.pass == 2)
1531 block_state.flags.value |= CONF_FLAGS_EXEMPTGLINE;
1532 } | RESV_EXEMPT
1533 {
1534 if (conf_parser_ctx.pass == 2)
1535 block_state.flags.value |= CONF_FLAGS_EXEMPTRESV;
1536 } | NEED_PASSWORD
1537 {
1538 if (conf_parser_ctx.pass == 2)
1539 block_state.flags.value |= CONF_FLAGS_NEED_PASSWORD;
1540 };
1541
1542 auth_spoof: SPOOF '=' QSTRING ';'
1543 {
1544 if (conf_parser_ctx.pass != 2)
1545 break;
1546
1547 if (strlen(yylval.string) <= HOSTLEN && valid_hostname(yylval.string))
1548 {
1549 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
1550 block_state.flags.value |= CONF_FLAGS_SPOOF_IP;
1551 }
1552 else
1553 ilog(LOG_TYPE_IRCD, "Spoof either is too long or contains invalid characters. Ignoring it.");
1554 };
1555
1556 auth_redir_serv: REDIRSERV '=' QSTRING ';'
1557 {
1558 if (conf_parser_ctx.pass != 2)
1559 break;
1560
1561 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
1562 block_state.flags.value |= CONF_FLAGS_REDIR;
1563 };
1564
1565 auth_redir_port: REDIRPORT '=' NUMBER ';'
1566 {
1567 if (conf_parser_ctx.pass != 2)
1568 break;
1569
1570 block_state.flags.value |= CONF_FLAGS_REDIR;
1571 block_state.port.value = $3;
1572 };
1573
1574
1575 /***************************************************************************
1576 * section resv
1577 ***************************************************************************/
1578 resv_entry: RESV
1579 {
1580 if (conf_parser_ctx.pass != 2)
1581 break;
1582
1583 reset_block_state();
1584 strlcpy(block_state.rpass.buf, CONF_NOREASON, sizeof(block_state.rpass.buf));
1585 } '{' resv_items '}' ';';
1586
1587 resv_items: resv_items resv_item | resv_item;
1588 resv_item: resv_creason | resv_channel | resv_nick | error ';' ;
1589
1590 resv_creason: REASON '=' QSTRING ';'
1591 {
1592 if (conf_parser_ctx.pass == 2)
1593 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
1594 };
1595
1596 resv_channel: CHANNEL '=' QSTRING ';'
1597 {
1598 if (conf_parser_ctx.pass != 2)
1599 break;
1600
1601 if (IsChanPrefix(*yylval.string))
1602 create_channel_resv(yylval.string, block_state.rpass.buf, 1);
1603 };
1604
1605 resv_nick: NICK '=' QSTRING ';'
1606 {
1607 if (conf_parser_ctx.pass == 2)
1608 create_nick_resv(yylval.string, block_state.rpass.buf, 1);
1609 };
1610
1611 /***************************************************************************
1612 * section service
1613 ***************************************************************************/
1614 service_entry: T_SERVICE '{' service_items '}' ';';
1615
1616 service_items: service_items service_item | service_item;
1617 service_item: service_name | error;
1618
1619 service_name: NAME '=' QSTRING ';'
1620 {
1621 if (conf_parser_ctx.pass == 2)
1622 {
1623 if (valid_servname(yylval.string))
1624 {
1625 struct MaskItem *conf = conf_make(CONF_SERVICE);
1626 conf->name = xstrdup(yylval.string);
1627 }
1628 }
1629 };
1630
1631 /***************************************************************************
1632 * section shared, for sharing remote klines etc.
1633 ***************************************************************************/
1634 shared_entry: T_SHARED
1635 {
1636 if (conf_parser_ctx.pass != 2)
1637 break;
1638
1639 reset_block_state();
1640
1641 strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
1642 strlcpy(block_state.user.buf, "*", sizeof(block_state.user.buf));
1643 strlcpy(block_state.host.buf, "*", sizeof(block_state.host.buf));
1644 block_state.flags.value = SHARED_ALL;
1645 } '{' shared_items '}' ';'
1646 {
1647 struct MaskItem *conf = NULL;
1648
1649 if (conf_parser_ctx.pass != 2)
1650 break;
1651
1652 conf = conf_make(CONF_ULINE);
1653 conf->flags = block_state.flags.value;
1654 conf->name = xstrdup(block_state.name.buf);
1655 conf->user = xstrdup(block_state.user.buf);
1656 conf->user = xstrdup(block_state.host.buf);
1657 };
1658
1659 shared_items: shared_items shared_item | shared_item;
1660 shared_item: shared_name | shared_user | shared_type | error ';' ;
1661
1662 shared_name: NAME '=' QSTRING ';'
1663 {
1664 if (conf_parser_ctx.pass == 2)
1665 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
1666 };
1667
1668 shared_user: USER '=' QSTRING ';'
1669 {
1670 if (conf_parser_ctx.pass == 2)
1671 {
1672 struct split_nuh_item nuh;
1673
1674 nuh.nuhmask = yylval.string;
1675 nuh.nickptr = NULL;
1676 nuh.userptr = block_state.user.buf;
1677 nuh.hostptr = block_state.host.buf;
1678
1679 nuh.nicksize = 0;
1680 nuh.usersize = sizeof(block_state.user.buf);
1681 nuh.hostsize = sizeof(block_state.host.buf);
1682
1683 split_nuh(&nuh);
1684 }
1685 };
1686
1687 shared_type: TYPE
1688 {
1689 if (conf_parser_ctx.pass == 2)
1690 block_state.flags.value = 0;
1691 } '=' shared_types ';' ;
1692
1693 shared_types: shared_types ',' shared_type_item | shared_type_item;
1694 shared_type_item: KLINE
1695 {
1696 if (conf_parser_ctx.pass == 2)
1697 block_state.flags.value |= SHARED_KLINE;
1698 } | UNKLINE
1699 {
1700 if (conf_parser_ctx.pass == 2)
1701 block_state.flags.value |= SHARED_UNKLINE;
1702 } | T_DLINE
1703 {
1704 if (conf_parser_ctx.pass == 2)
1705 block_state.flags.value |= SHARED_DLINE;
1706 } | T_UNDLINE
1707 {
1708 if (conf_parser_ctx.pass == 2)
1709 block_state.flags.value |= SHARED_UNDLINE;
1710 } | XLINE
1711 {
1712 if (conf_parser_ctx.pass == 2)
1713 block_state.flags.value |= SHARED_XLINE;
1714 } | T_UNXLINE
1715 {
1716 if (conf_parser_ctx.pass == 2)
1717 block_state.flags.value |= SHARED_UNXLINE;
1718 } | RESV
1719 {
1720 if (conf_parser_ctx.pass == 2)
1721 block_state.flags.value |= SHARED_RESV;
1722 } | T_UNRESV
1723 {
1724 if (conf_parser_ctx.pass == 2)
1725 block_state.flags.value |= SHARED_UNRESV;
1726 } | T_LOCOPS
1727 {
1728 if (conf_parser_ctx.pass == 2)
1729 block_state.flags.value |= SHARED_LOCOPS;
1730 } | T_ALL
1731 {
1732 if (conf_parser_ctx.pass == 2)
1733 block_state.flags.value = SHARED_ALL;
1734 };
1735
1736 /***************************************************************************
1737 * section cluster
1738 ***************************************************************************/
1739 cluster_entry: T_CLUSTER
1740 {
1741 if (conf_parser_ctx.pass != 2)
1742 break;
1743
1744 reset_block_state();
1745
1746 strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
1747 block_state.flags.value = SHARED_ALL;
1748 } '{' cluster_items '}' ';'
1749 {
1750 struct MaskItem *conf = NULL;
1751
1752 if (conf_parser_ctx.pass != 2)
1753 break;
1754
1755 conf = conf_make(CONF_CLUSTER);
1756 conf->flags = block_state.flags.value;
1757 conf->name = xstrdup(block_state.name.buf);
1758 };
1759
1760 cluster_items: cluster_items cluster_item | cluster_item;
1761 cluster_item: cluster_name | cluster_type | error ';' ;
1762
1763 cluster_name: NAME '=' QSTRING ';'
1764 {
1765 if (conf_parser_ctx.pass == 2)
1766 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
1767 };
1768
1769 cluster_type: TYPE
1770 {
1771 if (conf_parser_ctx.pass == 2)
1772 block_state.flags.value = 0;
1773 } '=' cluster_types ';' ;
1774
1775 cluster_types: cluster_types ',' cluster_type_item | cluster_type_item;
1776 cluster_type_item: KLINE
1777 {
1778 if (conf_parser_ctx.pass == 2)
1779 block_state.flags.value |= SHARED_KLINE;
1780 } | UNKLINE
1781 {
1782 if (conf_parser_ctx.pass == 2)
1783 block_state.flags.value |= SHARED_UNKLINE;
1784 } | T_DLINE
1785 {
1786 if (conf_parser_ctx.pass == 2)
1787 block_state.flags.value |= SHARED_DLINE;
1788 } | T_UNDLINE
1789 {
1790 if (conf_parser_ctx.pass == 2)
1791 block_state.flags.value |= SHARED_UNDLINE;
1792 } | XLINE
1793 {
1794 if (conf_parser_ctx.pass == 2)
1795 block_state.flags.value |= SHARED_XLINE;
1796 } | T_UNXLINE
1797 {
1798 if (conf_parser_ctx.pass == 2)
1799 block_state.flags.value |= SHARED_UNXLINE;
1800 } | RESV
1801 {
1802 if (conf_parser_ctx.pass == 2)
1803 block_state.flags.value |= SHARED_RESV;
1804 } | T_UNRESV
1805 {
1806 if (conf_parser_ctx.pass == 2)
1807 block_state.flags.value |= SHARED_UNRESV;
1808 } | T_LOCOPS
1809 {
1810 if (conf_parser_ctx.pass == 2)
1811 block_state.flags.value |= SHARED_LOCOPS;
1812 } | T_ALL
1813 {
1814 if (conf_parser_ctx.pass == 2)
1815 block_state.flags.value = SHARED_ALL;
1816 };
1817
1818 /***************************************************************************
1819 * section connect
1820 ***************************************************************************/
1821 connect_entry: CONNECT
1822 {
1823
1824 if (conf_parser_ctx.pass != 2)
1825 break;
1826
1827 reset_block_state();
1828 block_state.port.value = PORTNUM;
1829 } '{' connect_items '}' ';'
1830 {
1831 struct MaskItem *conf = NULL;
1832 struct addrinfo hints, *res;
1833
1834 if (conf_parser_ctx.pass != 2)
1835 break;
1836
1837 if (!(block_state.name.buf[0] ||
1838 block_state.host.buf[0]))
1839 break;
1840
1841 if (!(block_state.rpass.buf[0] ||
1842 block_state.spass.buf[0]))
1843 break;
1844
1845 if (has_wildcards(block_state.name.buf) ||
1846 has_wildcards(block_state.host.buf))
1847 break;
1848
1849 conf = conf_make(CONF_SERVER);
1850 conf->port = block_state.port.value;
1851 conf->flags = block_state.flags.value;
1852 conf->aftype = block_state.aftype.value;
1853 conf->host = xstrdup(block_state.host.buf);
1854 conf->name = xstrdup(block_state.name.buf);
1855 conf->passwd = xstrdup(block_state.rpass.buf);
1856 conf->spasswd = xstrdup(block_state.spass.buf);
1857 conf->cipher_list = xstrdup(block_state.ciph.buf);
1858
1859 dlinkMoveList(&block_state.leaf.list, &conf->leaf_list);
1860 dlinkMoveList(&block_state.hub.list, &conf->hub_list);
1861
1862 if (block_state.bind.buf[0])
1863 {
1864 memset(&hints, 0, sizeof(hints));
1865
1866 hints.ai_family = AF_UNSPEC;
1867 hints.ai_socktype = SOCK_STREAM;
1868 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
1869
1870 if (getaddrinfo(block_state.bind.buf, NULL, &hints, &res))
1871 ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", block_state.bind.buf);
1872 else
1873 {
1874 assert(res != NULL);
1875
1876 memcpy(&conf->bind, res->ai_addr, res->ai_addrlen);
1877 conf->bind.ss.ss_family = res->ai_family;
1878 conf->bind.ss_len = res->ai_addrlen;
1879 freeaddrinfo(res);
1880 }
1881 }
1882
1883 conf_add_class_to_conf(conf, block_state.class.buf);
1884 lookup_confhost(conf);
1885 };
1886
1887 connect_items: connect_items connect_item | connect_item;
1888 connect_item: connect_name | connect_host | connect_vhost |
1889 connect_send_password | connect_accept_password |
1890 connect_aftype | connect_port | connect_ssl_cipher_list |
1891 connect_flags | connect_hub_mask | connect_leaf_mask |
1892 connect_class | connect_encrypted |
1893 error ';' ;
1894
1895 connect_name: NAME '=' QSTRING ';'
1896 {
1897 if (conf_parser_ctx.pass == 2)
1898 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
1899 };
1900
1901 connect_host: HOST '=' QSTRING ';'
1902 {
1903 if (conf_parser_ctx.pass == 2)
1904 strlcpy(block_state.host.buf, yylval.string, sizeof(block_state.host.buf));
1905 };
1906
1907 connect_vhost: VHOST '=' QSTRING ';'
1908 {
1909 if (conf_parser_ctx.pass == 2)
1910 strlcpy(block_state.bind.buf, yylval.string, sizeof(block_state.bind.buf));
1911 };
1912
1913 connect_send_password: SEND_PASSWORD '=' QSTRING ';'
1914 {
1915 if (conf_parser_ctx.pass != 2)
1916 break;
1917
1918 if ($3[0] == ':')
1919 yyerror("Server passwords cannot begin with a colon");
1920 else if (strchr($3, ' ') != NULL)
1921 yyerror("Server passwords cannot contain spaces");
1922 else
1923 strlcpy(block_state.spass.buf, yylval.string, sizeof(block_state.spass.buf));
1924 };
1925
1926 connect_accept_password: ACCEPT_PASSWORD '=' QSTRING ';'
1927 {
1928 if (conf_parser_ctx.pass != 2)
1929 break;
1930
1931 if ($3[0] == ':')
1932 yyerror("Server passwords cannot begin with a colon");
1933 else if (strchr($3, ' ') != NULL)
1934 yyerror("Server passwords cannot contain spaces");
1935 else
1936 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
1937 };
1938
1939 connect_port: PORT '=' NUMBER ';'
1940 {
1941 if (conf_parser_ctx.pass == 2)
1942 block_state.port.value = $3;
1943 };
1944
1945 connect_aftype: AFTYPE '=' T_IPV4 ';'
1946 {
1947 if (conf_parser_ctx.pass == 2)
1948 block_state.aftype.value = AF_INET;
1949 } | AFTYPE '=' T_IPV6 ';'
1950 {
1951 #ifdef IPV6
1952 if (conf_parser_ctx.pass == 2)
1953 block_state.aftype.value = AF_INET6;
1954 #endif
1955 };
1956
1957 connect_flags: IRCD_FLAGS
1958 {
1959 /* XXX */
1960 } '=' connect_flags_items ';';
1961
1962 connect_flags_items: connect_flags_items ',' connect_flags_item | connect_flags_item;
1963 connect_flags_item: AUTOCONN
1964 {
1965 if (conf_parser_ctx.pass == 2)
1966 block_state.flags.value |= CONF_FLAGS_ALLOW_AUTO_CONN;
1967 } | T_SSL
1968 {
1969 if (conf_parser_ctx.pass == 2)
1970 block_state.flags.value |= CONF_FLAGS_SSL;
1971 };
1972
1973 connect_encrypted: ENCRYPTED '=' TBOOL ';'
1974 {
1975 if (conf_parser_ctx.pass == 2)
1976 {
1977 if (yylval.number)
1978 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
1979 else
1980 block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
1981 }
1982 };
1983
1984 connect_hub_mask: HUB_MASK '=' QSTRING ';'
1985 {
1986 if (conf_parser_ctx.pass == 2)
1987 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.hub.list);
1988 };
1989
1990 connect_leaf_mask: LEAF_MASK '=' QSTRING ';'
1991 {
1992 if (conf_parser_ctx.pass == 2)
1993 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.leaf.list);
1994 };
1995
1996 connect_class: CLASS '=' QSTRING ';'
1997 {
1998 if (conf_parser_ctx.pass == 2)
1999 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
2000 };
2001
2002 connect_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
2003 {
2004 #ifdef HAVE_LIBCRYPTO
2005 if (conf_parser_ctx.pass == 2)
2006 strlcpy(block_state.ciph.buf, yylval.string, sizeof(block_state.ciph.buf));
2007 #else
2008 if (conf_parser_ctx.pass == 2)
2009 yyerror("Ignoring connect::ciphers -- no OpenSSL support");
2010 #endif
2011 };
2012
2013
2014 /***************************************************************************
2015 * section kill
2016 ***************************************************************************/
2017 kill_entry: KILL
2018 {
2019 if (conf_parser_ctx.pass == 2)
2020 reset_block_state();
2021 } '{' kill_items '}' ';'
2022 {
2023 struct MaskItem *conf = NULL;
2024
2025 if (conf_parser_ctx.pass != 2)
2026 break;
2027
2028 if (!block_state.user.buf[0] ||
2029 !block_state.host.buf[0])
2030 break;
2031
2032
2033 if (block_state.port.value == 1)
2034 {
2035 #ifdef HAVE_LIBPCRE
2036 void *exp_user = NULL;
2037 void *exp_host = NULL;
2038 const char *errptr = NULL;
2039
2040 if (!(exp_user = ircd_pcre_compile(block_state.user.buf, &errptr)) ||
2041 !(exp_host = ircd_pcre_compile(block_state.host.buf, &errptr)))
2042 {
2043 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based K-Line: %s",
2044 errptr);
2045 break;
2046 }
2047
2048 conf = conf_make(CONF_RKLINE);
2049 conf->regexuser = exp_user;
2050 conf->regexhost = exp_host;
2051
2052 conf->user = xstrdup(block_state.user.buf);
2053 conf->host = xstrdup(block_state.host.buf);
2054
2055 if (block_state.rpass.buf[0])
2056 conf->reason = xstrdup(block_state.rpass.buf);
2057 else
2058 conf->reason = xstrdup(CONF_NOREASON);
2059 #else
2060 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based K-Line: no PCRE support");
2061 break;
2062 #endif
2063 }
2064 else
2065 {
2066 conf = conf_make(CONF_KLINE);
2067
2068 conf->user = xstrdup(block_state.user.buf);
2069 conf->host = xstrdup(block_state.host.buf);
2070
2071 if (block_state.rpass.buf[0])
2072 conf->reason = xstrdup(block_state.rpass.buf);
2073 else
2074 conf->reason = xstrdup(CONF_NOREASON);
2075 add_conf_by_address(CONF_KLINE, conf);
2076 }
2077 };
2078
2079 kill_type: TYPE
2080 {
2081 if (conf_parser_ctx.pass == 2)
2082 block_state.port.value = 0;
2083 } '=' kill_type_items ';';
2084
2085 kill_type_items: kill_type_items ',' kill_type_item | kill_type_item;
2086 kill_type_item: REGEX_T
2087 {
2088 if (conf_parser_ctx.pass == 2)
2089 block_state.port.value = 1;
2090 };
2091
2092 kill_items: kill_items kill_item | kill_item;
2093 kill_item: kill_user | kill_reason | kill_type | error;
2094
2095 kill_user: USER '=' QSTRING ';'
2096 {
2097
2098 if (conf_parser_ctx.pass == 2)
2099 {
2100 struct split_nuh_item nuh;
2101
2102 nuh.nuhmask = yylval.string;
2103 nuh.nickptr = NULL;
2104 nuh.userptr = block_state.user.buf;
2105 nuh.hostptr = block_state.host.buf;
2106
2107 nuh.nicksize = 0;
2108 nuh.usersize = sizeof(block_state.user.buf);
2109 nuh.hostsize = sizeof(block_state.host.buf);
2110
2111 split_nuh(&nuh);
2112 }
2113 };
2114
2115 kill_reason: REASON '=' QSTRING ';'
2116 {
2117 if (conf_parser_ctx.pass == 2)
2118 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2119 };
2120
2121 /***************************************************************************
2122 * section deny
2123 ***************************************************************************/
2124 deny_entry: DENY
2125 {
2126 if (conf_parser_ctx.pass == 2)
2127 reset_block_state();
2128 } '{' deny_items '}' ';'
2129 {
2130 struct MaskItem *conf = NULL;
2131
2132 if (conf_parser_ctx.pass != 2)
2133 break;
2134
2135 if (!block_state.addr.buf[0])
2136 break;
2137
2138 if (parse_netmask(block_state.addr.buf, NULL, NULL) != HM_HOST)
2139 {
2140 conf = conf_make(CONF_DLINE);
2141 conf->host = xstrdup(block_state.addr.buf);
2142
2143 if (block_state.rpass.buf[0])
2144 conf->reason = xstrdup(block_state.rpass.buf);
2145 else
2146 conf->reason = xstrdup(CONF_NOREASON);
2147 add_conf_by_address(CONF_DLINE, conf);
2148 }
2149 };
2150
2151 deny_items: deny_items deny_item | deny_item;
2152 deny_item: deny_ip | deny_reason | error;
2153
2154 deny_ip: IP '=' QSTRING ';'
2155 {
2156 if (conf_parser_ctx.pass == 2)
2157 strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
2158 };
2159
2160 deny_reason: REASON '=' QSTRING ';'
2161 {
2162 if (conf_parser_ctx.pass == 2)
2163 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2164 };
2165
2166 /***************************************************************************
2167 * section exempt
2168 ***************************************************************************/
2169 exempt_entry: EXEMPT '{' exempt_items '}' ';';
2170
2171 exempt_items: exempt_items exempt_item | exempt_item;
2172 exempt_item: exempt_ip | error;
2173
2174 exempt_ip: IP '=' QSTRING ';'
2175 {
2176 if (conf_parser_ctx.pass == 2)
2177 {
2178 if (yylval.string[0] && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
2179 {
2180 struct MaskItem *conf = conf_make(CONF_EXEMPT);
2181 conf->host = xstrdup(yylval.string);
2182
2183 add_conf_by_address(CONF_EXEMPT, conf);
2184 }
2185 }
2186 };
2187
2188 /***************************************************************************
2189 * section gecos
2190 ***************************************************************************/
2191 gecos_entry: GECOS
2192 {
2193 if (conf_parser_ctx.pass == 2)
2194 reset_block_state();
2195 } '{' gecos_items '}' ';'
2196 {
2197 struct MaskItem *conf = NULL;
2198
2199 if (conf_parser_ctx.pass != 2)
2200 break;
2201
2202 if (!block_state.name.buf[0])
2203 break;
2204
2205 if (block_state.port.value == 1)
2206 {
2207 #ifdef HAVE_LIBPCRE
2208 void *exp_p = NULL;
2209 const char *errptr = NULL;
2210
2211 if (!(exp_p = ircd_pcre_compile(block_state.name.buf, &errptr)))
2212 {
2213 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based X-Line: %s",
2214 errptr);
2215 break;
2216 }
2217
2218 conf = conf_make(CONF_RXLINE);
2219 conf->regexuser = exp_p;
2220 #else
2221 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based X-Line: no PCRE support");
2222 break;
2223 #endif
2224 }
2225 else
2226 conf = conf_make(CONF_XLINE);
2227
2228 conf->name = xstrdup(block_state.name.buf);
2229
2230 if (block_state.rpass.buf[0])
2231 conf->reason = xstrdup(block_state.rpass.buf);
2232 else
2233 conf->reason = xstrdup(CONF_NOREASON);
2234 };
2235
2236 gecos_flags: TYPE
2237 {
2238 if (conf_parser_ctx.pass == 2)
2239 block_state.port.value = 0;
2240 } '=' gecos_flags_items ';';
2241
2242 gecos_flags_items: gecos_flags_items ',' gecos_flags_item | gecos_flags_item;
2243 gecos_flags_item: REGEX_T
2244 {
2245 if (conf_parser_ctx.pass == 2)
2246 block_state.port.value = 1;
2247 };
2248
2249 gecos_items: gecos_items gecos_item | gecos_item;
2250 gecos_item: gecos_name | gecos_reason | gecos_flags | error;
2251
2252 gecos_name: NAME '=' QSTRING ';'
2253 {
2254 if (conf_parser_ctx.pass == 2)
2255 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
2256 };
2257
2258 gecos_reason: REASON '=' QSTRING ';'
2259 {
2260 if (conf_parser_ctx.pass == 2)
2261 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2262 };
2263
2264 /***************************************************************************
2265 * section general
2266 ***************************************************************************/
2267 general_entry: GENERAL
2268 '{' general_items '}' ';';
2269
2270 general_items: general_items general_item | general_item;
2271 general_item: general_hide_spoof_ips | general_ignore_bogus_ts |
2272 general_failed_oper_notice | general_anti_nick_flood |
2273 general_max_nick_time | general_max_nick_changes |
2274 general_max_accept | general_anti_spam_exit_message_time |
2275 general_ts_warn_delta | general_ts_max_delta |
2276 general_kill_chase_time_limit |
2277 general_invisible_on_connect |
2278 general_warn_no_nline | general_dots_in_ident |
2279 general_stats_o_oper_only | general_stats_k_oper_only |
2280 general_pace_wait | general_stats_i_oper_only |
2281 general_pace_wait_simple | general_stats_P_oper_only |
2282 general_short_motd | general_no_oper_flood |
2283 general_true_no_oper_flood | general_oper_pass_resv |
2284 general_message_locale |
2285 general_oper_only_umodes | general_max_targets |
2286 general_use_egd | general_egdpool_path |
2287 general_oper_umodes | general_caller_id_wait |
2288 general_opers_bypass_callerid | general_default_floodcount |
2289 general_min_nonwildcard | general_min_nonwildcard_simple |
2290 general_disable_remote_commands |
2291 general_throttle_time | general_havent_read_conf |
2292 general_ping_cookie |
2293 general_disable_auth |
2294 general_tkline_expire_notices | general_gline_enable |
2295 general_gline_duration | general_gline_request_duration |
2296 general_gline_min_cidr |
2297 general_gline_min_cidr6 |
2298 general_stats_e_disabled |
2299 general_max_watch | general_services_name |
2300 error;
2301
2302
2303 general_max_watch: MAX_WATCH '=' NUMBER ';'
2304 {
2305 ConfigFileEntry.max_watch = $3;
2306 };
2307
2308 general_gline_enable: GLINE_ENABLE '=' TBOOL ';'
2309 {
2310 if (conf_parser_ctx.pass == 2)
2311 ConfigFileEntry.glines = yylval.number;
2312 };
2313
2314 general_gline_duration: GLINE_DURATION '=' timespec ';'
2315 {
2316 if (conf_parser_ctx.pass == 2)
2317 ConfigFileEntry.gline_time = $3;
2318 };
2319
2320 general_gline_request_duration: GLINE_REQUEST_DURATION '=' timespec ';'
2321 {
2322 if (conf_parser_ctx.pass == 2)
2323 ConfigFileEntry.gline_request_time = $3;
2324 };
2325
2326 general_gline_min_cidr: GLINE_MIN_CIDR '=' NUMBER ';'
2327 {
2328 ConfigFileEntry.gline_min_cidr = $3;
2329 };
2330
2331 general_gline_min_cidr6: GLINE_MIN_CIDR6 '=' NUMBER ';'
2332 {
2333 ConfigFileEntry.gline_min_cidr6 = $3;
2334 };
2335
2336 general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
2337 {
2338 ConfigFileEntry.tkline_expire_notices = yylval.number;
2339 };
2340
2341 general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' timespec ';'
2342 {
2343 ConfigFileEntry.kill_chase_time_limit = $3;
2344 };
2345
2346 general_hide_spoof_ips: HIDE_SPOOF_IPS '=' TBOOL ';'
2347 {
2348 ConfigFileEntry.hide_spoof_ips = yylval.number;
2349 };
2350
2351 general_ignore_bogus_ts: IGNORE_BOGUS_TS '=' TBOOL ';'
2352 {
2353 ConfigFileEntry.ignore_bogus_ts = yylval.number;
2354 };
2355
2356 general_disable_remote_commands: DISABLE_REMOTE_COMMANDS '=' TBOOL ';'
2357 {
2358 ConfigFileEntry.disable_remote = yylval.number;
2359 };
2360
2361 general_failed_oper_notice: FAILED_OPER_NOTICE '=' TBOOL ';'
2362 {
2363 ConfigFileEntry.failed_oper_notice = yylval.number;
2364 };
2365
2366 general_anti_nick_flood: ANTI_NICK_FLOOD '=' TBOOL ';'
2367 {
2368 ConfigFileEntry.anti_nick_flood = yylval.number;
2369 };
2370
2371 general_max_nick_time: MAX_NICK_TIME '=' timespec ';'
2372 {
2373 ConfigFileEntry.max_nick_time = $3;
2374 };
2375
2376 general_max_nick_changes: MAX_NICK_CHANGES '=' NUMBER ';'
2377 {
2378 ConfigFileEntry.max_nick_changes = $3;
2379 };
2380
2381 general_max_accept: MAX_ACCEPT '=' NUMBER ';'
2382 {
2383 ConfigFileEntry.max_accept = $3;
2384 };
2385
2386 general_anti_spam_exit_message_time: ANTI_SPAM_EXIT_MESSAGE_TIME '=' timespec ';'
2387 {
2388 ConfigFileEntry.anti_spam_exit_message_time = $3;
2389 };
2390
2391 general_ts_warn_delta: TS_WARN_DELTA '=' timespec ';'
2392 {
2393 ConfigFileEntry.ts_warn_delta = $3;
2394 };
2395
2396 general_ts_max_delta: TS_MAX_DELTA '=' timespec ';'
2397 {
2398 if (conf_parser_ctx.pass == 2)
2399 ConfigFileEntry.ts_max_delta = $3;
2400 };
2401
2402 general_havent_read_conf: HAVENT_READ_CONF '=' NUMBER ';'
2403 {
2404 if (($3 > 0) && conf_parser_ctx.pass == 1)
2405 {
2406 ilog(LOG_TYPE_IRCD, "You haven't read your config file properly.");
2407 ilog(LOG_TYPE_IRCD, "There is a line in the example conf that will kill your server if not removed.");
2408 ilog(LOG_TYPE_IRCD, "Consider actually reading/editing the conf file, and removing this line.");
2409 exit(0);
2410 }
2411 };
2412
2413 general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
2414 {
2415 ConfigFileEntry.invisible_on_connect = yylval.number;
2416 };
2417
2418 general_warn_no_nline: WARN_NO_NLINE '=' TBOOL ';'
2419 {
2420 ConfigFileEntry.warn_no_nline = yylval.number;
2421 };
2422
2423 general_stats_e_disabled: STATS_E_DISABLED '=' TBOOL ';'
2424 {
2425 ConfigFileEntry.stats_e_disabled = yylval.number;
2426 };
2427
2428 general_stats_o_oper_only: STATS_O_OPER_ONLY '=' TBOOL ';'
2429 {
2430 ConfigFileEntry.stats_o_oper_only = yylval.number;
2431 };
2432
2433 general_stats_P_oper_only: STATS_P_OPER_ONLY '=' TBOOL ';'
2434 {
2435 ConfigFileEntry.stats_P_oper_only = yylval.number;
2436 };
2437
2438 general_stats_k_oper_only: STATS_K_OPER_ONLY '=' TBOOL ';'
2439 {
2440 ConfigFileEntry.stats_k_oper_only = 2 * yylval.number;
2441 } | STATS_K_OPER_ONLY '=' TMASKED ';'
2442 {
2443 ConfigFileEntry.stats_k_oper_only = 1;
2444 };
2445
2446 general_stats_i_oper_only: STATS_I_OPER_ONLY '=' TBOOL ';'
2447 {
2448 ConfigFileEntry.stats_i_oper_only = 2 * yylval.number;
2449 } | STATS_I_OPER_ONLY '=' TMASKED ';'
2450 {
2451 ConfigFileEntry.stats_i_oper_only = 1;
2452 };
2453
2454 general_pace_wait: PACE_WAIT '=' timespec ';'
2455 {
2456 ConfigFileEntry.pace_wait = $3;
2457 };
2458
2459 general_caller_id_wait: CALLER_ID_WAIT '=' timespec ';'
2460 {
2461 ConfigFileEntry.caller_id_wait = $3;
2462 };
2463
2464 general_opers_bypass_callerid: OPERS_BYPASS_CALLERID '=' TBOOL ';'
2465 {
2466 ConfigFileEntry.opers_bypass_callerid = yylval.number;
2467 };
2468
2469 general_pace_wait_simple: PACE_WAIT_SIMPLE '=' timespec ';'
2470 {
2471 ConfigFileEntry.pace_wait_simple = $3;
2472 };
2473
2474 general_short_motd: SHORT_MOTD '=' TBOOL ';'
2475 {
2476 ConfigFileEntry.short_motd = yylval.number;
2477 };
2478
2479 general_no_oper_flood: NO_OPER_FLOOD '=' TBOOL ';'
2480 {
2481 ConfigFileEntry.no_oper_flood = yylval.number;
2482 };
2483
2484 general_true_no_oper_flood: TRUE_NO_OPER_FLOOD '=' TBOOL ';'
2485 {
2486 ConfigFileEntry.true_no_oper_flood = yylval.number;
2487 };
2488
2489 general_oper_pass_resv: OPER_PASS_RESV '=' TBOOL ';'
2490 {
2491 ConfigFileEntry.oper_pass_resv = yylval.number;
2492 };
2493
2494 general_message_locale: MESSAGE_LOCALE '=' QSTRING ';'
2495 {
2496 if (conf_parser_ctx.pass == 2)
2497 {
2498 if (strlen(yylval.string) > LOCALE_LENGTH-2)
2499 yylval.string[LOCALE_LENGTH-1] = '\0';
2500
2501 set_locale(yylval.string);
2502 }
2503 };
2504
2505 general_dots_in_ident: DOTS_IN_IDENT '=' NUMBER ';'
2506 {
2507 ConfigFileEntry.dots_in_ident = $3;
2508 };
2509
2510 general_max_targets: MAX_TARGETS '=' NUMBER ';'
2511 {
2512 ConfigFileEntry.max_targets = $3;
2513 };
2514
2515 general_use_egd: USE_EGD '=' TBOOL ';'
2516 {
2517 ConfigFileEntry.use_egd = yylval.number;
2518 };
2519
2520 general_egdpool_path: EGDPOOL_PATH '=' QSTRING ';'
2521 {
2522 if (conf_parser_ctx.pass == 2)
2523 {
2524 MyFree(ConfigFileEntry.egdpool_path);
2525 ConfigFileEntry.egdpool_path = xstrdup(yylval.string);
2526 }
2527 };
2528
2529 general_services_name: T_SERVICES_NAME '=' QSTRING ';'
2530 {
2531 if (conf_parser_ctx.pass == 2 && valid_servname(yylval.string))
2532 {
2533 MyFree(ConfigFileEntry.service_name);
2534 ConfigFileEntry.service_name = xstrdup(yylval.string);
2535 }
2536 };
2537
2538 general_ping_cookie: PING_COOKIE '=' TBOOL ';'
2539 {
2540 ConfigFileEntry.ping_cookie = yylval.number;
2541 };
2542
2543 general_disable_auth: DISABLE_AUTH '=' TBOOL ';'
2544 {
2545 ConfigFileEntry.disable_auth = yylval.number;
2546 };
2547
2548 general_throttle_time: THROTTLE_TIME '=' timespec ';'
2549 {
2550 ConfigFileEntry.throttle_time = yylval.number;
2551 };
2552
2553 general_oper_umodes: OPER_UMODES
2554 {
2555 ConfigFileEntry.oper_umodes = 0;
2556 } '=' umode_oitems ';' ;
2557
2558 umode_oitems: umode_oitems ',' umode_oitem | umode_oitem;
2559 umode_oitem: T_BOTS
2560 {
2561 ConfigFileEntry.oper_umodes |= UMODE_BOTS;
2562 } | T_CCONN
2563 {
2564 ConfigFileEntry.oper_umodes |= UMODE_CCONN;
2565 } | T_CCONN_FULL
2566 {
2567 ConfigFileEntry.oper_umodes |= UMODE_CCONN_FULL;
2568 } | T_DEAF
2569 {
2570 ConfigFileEntry.oper_umodes |= UMODE_DEAF;
2571 } | T_DEBUG
2572 {
2573 ConfigFileEntry.oper_umodes |= UMODE_DEBUG;
2574 } | T_FULL
2575 {
2576 ConfigFileEntry.oper_umodes |= UMODE_FULL;
2577 } | HIDDEN
2578 {
2579 ConfigFileEntry.oper_umodes |= UMODE_HIDDEN;
2580 } | T_SKILL
2581 {
2582 ConfigFileEntry.oper_umodes |= UMODE_SKILL;
2583 } | T_NCHANGE
2584 {
2585 ConfigFileEntry.oper_umodes |= UMODE_NCHANGE;
2586 } | T_REJ
2587 {
2588 ConfigFileEntry.oper_umodes |= UMODE_REJ;
2589 } | T_UNAUTH
2590 {
2591 ConfigFileEntry.oper_umodes |= UMODE_UNAUTH;
2592 } | T_SPY
2593 {
2594 ConfigFileEntry.oper_umodes |= UMODE_SPY;
2595 } | T_EXTERNAL
2596 {
2597 ConfigFileEntry.oper_umodes |= UMODE_EXTERNAL;
2598 } | T_OPERWALL
2599 {
2600 ConfigFileEntry.oper_umodes |= UMODE_OPERWALL;
2601 } | T_SERVNOTICE
2602 {
2603 ConfigFileEntry.oper_umodes |= UMODE_SERVNOTICE;
2604 } | T_INVISIBLE
2605 {
2606 ConfigFileEntry.oper_umodes |= UMODE_INVISIBLE;
2607 } | T_WALLOP
2608 {
2609 ConfigFileEntry.oper_umodes |= UMODE_WALLOP;
2610 } | T_SOFTCALLERID
2611 {
2612 ConfigFileEntry.oper_umodes |= UMODE_SOFTCALLERID;
2613 } | T_CALLERID
2614 {
2615 ConfigFileEntry.oper_umodes |= UMODE_CALLERID;
2616 } | T_LOCOPS
2617 {
2618 ConfigFileEntry.oper_umodes |= UMODE_LOCOPS;
2619 };
2620
2621 general_oper_only_umodes: OPER_ONLY_UMODES
2622 {
2623 ConfigFileEntry.oper_only_umodes = 0;
2624 } '=' umode_items ';' ;
2625
2626 umode_items: umode_items ',' umode_item | umode_item;
2627 umode_item: T_BOTS
2628 {
2629 ConfigFileEntry.oper_only_umodes |= UMODE_BOTS;
2630 } | T_CCONN
2631 {
2632 ConfigFileEntry.oper_only_umodes |= UMODE_CCONN;
2633 } | T_CCONN_FULL
2634 {
2635 ConfigFileEntry.oper_only_umodes |= UMODE_CCONN_FULL;
2636 } | T_DEAF
2637 {
2638 ConfigFileEntry.oper_only_umodes |= UMODE_DEAF;
2639 } | T_DEBUG
2640 {
2641 ConfigFileEntry.oper_only_umodes |= UMODE_DEBUG;
2642 } | T_FULL
2643 {
2644 ConfigFileEntry.oper_only_umodes |= UMODE_FULL;
2645 } | T_SKILL
2646 {
2647 ConfigFileEntry.oper_only_umodes |= UMODE_SKILL;
2648 } | HIDDEN
2649 {
2650 ConfigFileEntry.oper_only_umodes |= UMODE_HIDDEN;
2651 } | T_NCHANGE
2652 {
2653 ConfigFileEntry.oper_only_umodes |= UMODE_NCHANGE;
2654 } | T_REJ
2655 {
2656 ConfigFileEntry.oper_only_umodes |= UMODE_REJ;
2657 } | T_UNAUTH
2658 {
2659 ConfigFileEntry.oper_only_umodes |= UMODE_UNAUTH;
2660 } | T_SPY
2661 {
2662 ConfigFileEntry.oper_only_umodes |= UMODE_SPY;
2663 } | T_EXTERNAL
2664 {
2665 ConfigFileEntry.oper_only_umodes |= UMODE_EXTERNAL;
2666 } | T_OPERWALL
2667 {
2668 ConfigFileEntry.oper_only_umodes |= UMODE_OPERWALL;
2669 } | T_SERVNOTICE
2670 {
2671 ConfigFileEntry.oper_only_umodes |= UMODE_SERVNOTICE;
2672 } | T_INVISIBLE
2673 {
2674 ConfigFileEntry.oper_only_umodes |= UMODE_INVISIBLE;
2675 } | T_WALLOP
2676 {
2677 ConfigFileEntry.oper_only_umodes |= UMODE_WALLOP;
2678 } | T_SOFTCALLERID
2679 {
2680 ConfigFileEntry.oper_only_umodes |= UMODE_SOFTCALLERID;
2681 } | T_CALLERID
2682 {
2683 ConfigFileEntry.oper_only_umodes |= UMODE_CALLERID;
2684 } | T_LOCOPS
2685 {
2686 ConfigFileEntry.oper_only_umodes |= UMODE_LOCOPS;
2687 };
2688
2689 general_min_nonwildcard: MIN_NONWILDCARD '=' NUMBER ';'
2690 {
2691 ConfigFileEntry.min_nonwildcard = $3;
2692 };
2693
2694 general_min_nonwildcard_simple: MIN_NONWILDCARD_SIMPLE '=' NUMBER ';'
2695 {
2696 ConfigFileEntry.min_nonwildcard_simple = $3;
2697 };
2698
2699 general_default_floodcount: DEFAULT_FLOODCOUNT '=' NUMBER ';'
2700 {
2701 ConfigFileEntry.default_floodcount = $3;
2702 };
2703
2704
2705 /***************************************************************************
2706 * section channel
2707 ***************************************************************************/
2708 channel_entry: CHANNEL
2709 '{' channel_items '}' ';';
2710
2711 channel_items: channel_items channel_item | channel_item;
2712 channel_item: channel_max_bans |
2713 channel_knock_delay | channel_knock_delay_channel |
2714 channel_max_chans_per_user | channel_max_chans_per_oper |
2715 channel_quiet_on_ban | channel_default_split_user_count |
2716 channel_default_split_server_count |
2717 channel_no_create_on_split | channel_restrict_channels |
2718 channel_no_join_on_split |
2719 channel_jflood_count | channel_jflood_time |
2720 channel_disable_fake_channels | error;
2721
2722 channel_disable_fake_channels: DISABLE_FAKE_CHANNELS '=' TBOOL ';'
2723 {
2724 ConfigChannel.disable_fake_channels = yylval.number;
2725 };
2726
2727 channel_restrict_channels: RESTRICT_CHANNELS '=' TBOOL ';'
2728 {
2729 ConfigChannel.restrict_channels = yylval.number;
2730 };
2731
2732 channel_knock_delay: KNOCK_DELAY '=' timespec ';'
2733 {
2734 ConfigChannel.knock_delay = $3;
2735 };
2736
2737 channel_knock_delay_channel: KNOCK_DELAY_CHANNEL '=' timespec ';'
2738 {
2739 ConfigChannel.knock_delay_channel = $3;
2740 };
2741
2742 channel_max_chans_per_user: MAX_CHANS_PER_USER '=' NUMBER ';'
2743 {
2744 ConfigChannel.max_chans_per_user = $3;
2745 };
2746
2747 channel_max_chans_per_oper: MAX_CHANS_PER_OPER '=' NUMBER ';'
2748 {
2749 ConfigChannel.max_chans_per_oper = $3;
2750 };
2751
2752 channel_quiet_on_ban: QUIET_ON_BAN '=' TBOOL ';'
2753 {
2754 ConfigChannel.quiet_on_ban = yylval.number;
2755 };
2756
2757 channel_max_bans: MAX_BANS '=' NUMBER ';'
2758 {
2759 ConfigChannel.max_bans = $3;
2760 };
2761
2762 channel_default_split_user_count: DEFAULT_SPLIT_USER_COUNT '=' NUMBER ';'
2763 {
2764 ConfigChannel.default_split_user_count = $3;
2765 };
2766
2767 channel_default_split_server_count: DEFAULT_SPLIT_SERVER_COUNT '=' NUMBER ';'
2768 {
2769 ConfigChannel.default_split_server_count = $3;
2770 };
2771
2772 channel_no_create_on_split: NO_CREATE_ON_SPLIT '=' TBOOL ';'
2773 {
2774 ConfigChannel.no_create_on_split = yylval.number;
2775 };
2776
2777 channel_no_join_on_split: NO_JOIN_ON_SPLIT '=' TBOOL ';'
2778 {
2779 ConfigChannel.no_join_on_split = yylval.number;
2780 };
2781
2782 channel_jflood_count: JOIN_FLOOD_COUNT '=' NUMBER ';'
2783 {
2784 GlobalSetOptions.joinfloodcount = yylval.number;
2785 };
2786
2787 channel_jflood_time: JOIN_FLOOD_TIME '=' timespec ';'
2788 {
2789 GlobalSetOptions.joinfloodtime = yylval.number;
2790 };
2791
2792 /***************************************************************************
2793 * section serverhide
2794 ***************************************************************************/
2795 serverhide_entry: SERVERHIDE
2796 '{' serverhide_items '}' ';';
2797
2798 serverhide_items: serverhide_items serverhide_item | serverhide_item;
2799 serverhide_item: serverhide_flatten_links | serverhide_hide_servers |
2800 serverhide_links_delay |
2801 serverhide_hidden | serverhide_hidden_name |
2802 serverhide_hide_server_ips |
2803 error;
2804
2805 serverhide_flatten_links: FLATTEN_LINKS '=' TBOOL ';'
2806 {
2807 if (conf_parser_ctx.pass == 2)
2808 ConfigServerHide.flatten_links = yylval.number;
2809 };
2810
2811 serverhide_hide_servers: HIDE_SERVERS '=' TBOOL ';'
2812 {
2813 if (conf_parser_ctx.pass == 2)
2814 ConfigServerHide.hide_servers = yylval.number;
2815 };
2816
2817 serverhide_hidden_name: HIDDEN_NAME '=' QSTRING ';'
2818 {
2819 if (conf_parser_ctx.pass == 2)
2820 {
2821 MyFree(ConfigServerHide.hidden_name);
2822 ConfigServerHide.hidden_name = xstrdup(yylval.string);
2823 }
2824 };
2825
2826 serverhide_links_delay: LINKS_DELAY '=' timespec ';'
2827 {
2828 if (conf_parser_ctx.pass == 2)
2829 {
2830 if (($3 > 0) && ConfigServerHide.links_disabled == 1)
2831 {
2832 eventAddIsh("write_links_file", write_links_file, NULL, $3);
2833 ConfigServerHide.links_disabled = 0;
2834 }
2835
2836 ConfigServerHide.links_delay = $3;
2837 }
2838 };
2839
2840 serverhide_hidden: HIDDEN '=' TBOOL ';'
2841 {
2842 if (conf_parser_ctx.pass == 2)
2843 ConfigServerHide.hidden = yylval.number;
2844 };
2845
2846 serverhide_hide_server_ips: HIDE_SERVER_IPS '=' TBOOL ';'
2847 {
2848 if (conf_parser_ctx.pass == 2)
2849 ConfigServerHide.hide_server_ips = yylval.number;
2850 };

Properties

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

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