/[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 1831 - (show annotations)
Mon Apr 15 10:57:05 2013 UTC (7 years, 9 months ago) by michael
File size: 74647 byte(s)
- Forward-port -r1741 [Fixed logfiles not getting reopened on /rehash]

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

Properties

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

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