ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 6318
Committed: Wed Aug 5 16:04:43 2015 UTC (10 years ago) by michael
File size: 78548 byte(s)
Log Message: 
- Get rid of UMODE_ALL

File Contents

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

Properties

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