/[svn]/ircd-hybrid/branches/8.1.x/src/conf_parser.y
ViewVC logotype

Contents of /ircd-hybrid/branches/8.1.x/src/conf_parser.y

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2284 - (show annotations)
Tue Jun 18 19:16:46 2013 UTC (9 years, 1 month ago) by michael
File size: 75184 byte(s)
- Added generall::cycle_on_host_change configuration option as requested
  by Adam <adam@anope.org>

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

Properties

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

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