/[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 1785 - (show annotations)
Sat Jan 26 22:40:55 2013 UTC (7 years, 7 months ago) by michael
File size: 74469 byte(s)
- Forward-port -r1784 [Fix bug where idle time sometimes is 0 even if the
  client didn't send any private message]

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

Properties

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

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