ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 4545
Committed: Fri Aug 22 08:46:13 2014 UTC (9 years, 7 months ago) by michael
File size: 79825 byte(s)
Log Message:
- Implemented pseudo {} blocks (service aliases)
- Fixed compile warnings with -Wmissing-field-initializers

File Contents

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

Properties

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