ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 2129
Committed: Wed May 29 13:12:15 2013 UTC (10 years, 10 months ago) by michael
File size: 72993 byte(s)
Log Message:
- conf_parser.l, conf_parser.y: style corrections

File Contents

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

Properties

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