ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 4624
Committed: Sun Sep 21 08:41:22 2014 UTC (9 years, 6 months ago) by michael
File size: 79731 byte(s)
Log Message:
- conf_parser.y: use SSL_CTX_use_certificate_chain_file() instead of SSL_CTX_use_certificate_file()

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

Properties

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