ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/conf_parser.y

Comparing ircd-hybrid/trunk/src/conf_parser.y (file contents):
Revision 2252 by michael, Sun Jun 16 13:29:13 2013 UTC vs.
Revision 5414 by michael, Sun Jan 25 17:40:40 2015 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  conf_parser.y: Parses the ircd configuration file.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2005 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 2000-2015 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 16 | Line 15
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
18	>	*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19		*  USA
21	–	*
22	–	*  $Id$
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
#	Line 34 | Line 37
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 "s_serv.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 "s_user.h"
53	>	#include "user.h"
54		#include "motd.h"
55
56		#ifdef HAVE_LIBCRYPTO
#	Line 62 | Line 66 | int yylex(void);
66
67		static struct
68		{
69	<	struct {
69	>	struct
70	>	{
71		dlink_list list;
72		} mask,
73		leaf,
74		hub;
75
76	<	struct {
76	>	struct
77	>	{
78		char buf[IRCD_BUFSIZE];
79		} name,
80	+	nick,
81		user,
82		host,
83		addr,
#	Line 80 | Line 87 | static struct
87		cert,
88		rpass,
89		spass,
90	<	class;
90	>	class,
91	>	target,
92	>	prepend,
93	>	command;
94
95	<	struct {
95	>	struct
96	>	{
97		unsigned int value;
98		} flags,
99		modes,
#	Line 101 | Line 112 | static struct
112		max_ident,
113		max_sendq,
114		max_recvq,
115	+	max_channels,
116		cidr_bitlen_ipv4,
117		cidr_bitlen_ipv6,
118		number_per_cidr;
#	Line 109 | Line 121 | static struct
121		static void
122		reset_block_state(void)
123		{
124	<	dlink_node *ptr = NULL, *ptr_next = NULL;
124	>	dlink_node *node = NULL, *node_next = NULL;
125
126	<	DLINK_FOREACH_SAFE(ptr, ptr_next, block_state.mask.list.head)
126	>	DLINK_FOREACH_SAFE(node, node_next, block_state.mask.list.head)
127		{
128	<	MyFree(ptr->data);
129	<	dlinkDelete(ptr, &block_state.mask.list);
130	<	free_dlink_node(ptr);
128	>	MyFree(node->data);
129	>	dlinkDelete(node, &block_state.mask.list);
130	>	free_dlink_node(node);
131		}
132
133	<	DLINK_FOREACH_SAFE(ptr, ptr_next, block_state.leaf.list.head)
133	>	DLINK_FOREACH_SAFE(node, node_next, block_state.leaf.list.head)
134		{
135	<	MyFree(ptr->data);
136	<	dlinkDelete(ptr, &block_state.leaf.list);
137	<	free_dlink_node(ptr);
135	>	MyFree(node->data);
136	>	dlinkDelete(node, &block_state.leaf.list);
137	>	free_dlink_node(node);
138		}
139
140	<	DLINK_FOREACH_SAFE(ptr, ptr_next, block_state.hub.list.head)
140	>	DLINK_FOREACH_SAFE(node, node_next, block_state.hub.list.head)
141		{
142	<	MyFree(ptr->data);
143	<	dlinkDelete(ptr, &block_state.hub.list);
144	<	free_dlink_node(ptr);
142	>	MyFree(node->data);
143	>	dlinkDelete(node, &block_state.hub.list);
144	>	free_dlink_node(node);
145		}
146
147		memset(&block_state, 0, sizeof(block_state));
#	Line 148 | Line 160 | reset_block_state(void)
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
#	Line 157 | Line 171 | reset_block_state(void)
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
#	Line 167 | Line 182 | reset_block_state(void)
182		%token  DISABLE_FAKE_CHANNELS
183		%token  DISABLE_REMOTE_COMMANDS
184		%token  DOTS_IN_IDENT
170	–	%token  EGDPOOL_PATH
185		%token  EMAIL
186		%token  ENCRYPTED
187		%token  EXCEED_LIMIT
#	Line 187 | Line 201 | reset_block_state(void)
201		%token  HAVENT_READ_CONF
202		%token  HIDDEN
203		%token  HIDDEN_NAME
204	+	%token  HIDE_CHANS
205	+	%token  HIDE_IDLE
206		%token  HIDE_IDLE_FROM_OPERS
207		%token  HIDE_SERVER_IPS
208		%token  HIDE_SERVERS
#	Line 197 | Line 213 | reset_block_state(void)
213		%token  HUB_MASK
214		%token  IGNORE_BOGUS_TS
215		%token  INVISIBLE_ON_CONNECT
216	+	%token  INVITE_CLIENT_COUNT
217	+	%token  INVITE_CLIENT_TIME
218		%token  IP
219		%token  IRCD_AUTH
220		%token  IRCD_FLAGS
#	Line 207 | Line 225 | reset_block_state(void)
225		%token  KILL_CHASE_TIME_LIMIT
226		%token  KLINE
227		%token  KLINE_EXEMPT
228	<	%token  KNOCK_DELAY
228	>	%token  KNOCK_CLIENT_COUNT
229	>	%token  KNOCK_CLIENT_TIME
230		%token  KNOCK_DELAY_CHANNEL
231		%token  LEAF_MASK
232		%token  LINKS_DELAY
#	Line 215 | Line 234 | reset_block_state(void)
234		%token  MASK
235		%token  MAX_ACCEPT
236		%token  MAX_BANS
237	<	%token  MAX_CHANS_PER_OPER
219	<	%token  MAX_CHANS_PER_USER
237	>	%token  MAX_CHANNELS
238		%token  MAX_GLOBAL
239		%token  MAX_IDENT
240		%token  MAX_IDLE
#	Line 283 | Line 301 | reset_block_state(void)
301		%token  SSL_CERTIFICATE_FILE
302		%token  SSL_CERTIFICATE_FINGERPRINT
303		%token  SSL_CONNECTION_REQUIRED
304	+	%token  SSL_DH_ELLIPTIC_CURVE
305		%token  SSL_DH_PARAM_FILE
306	+	%token  SSL_MESSAGE_DIGEST_ALGORITHM
307		%token  STATS_E_DISABLED
308		%token  STATS_I_OPER_ONLY
309		%token  STATS_K_OPER_ONLY
310	+	%token  STATS_M_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
#	Line 310 | Line 333 | reset_block_state(void)
333		%token  T_MAX_CLIENTS
334		%token  T_NCHANGE
335		%token  T_NONONREG
336	<	%token  T_OPERWALL
336	>	%token  T_OPME
337	>	%token  T_PREPEND
338	>	%token  T_PSEUDO
339		%token  T_RECVQ
340		%token  T_REJ
341		%token  T_RESTART
342		%token  T_SERVER
343		%token  T_SERVICE
319	–	%token  T_SERVICES_NAME
344		%token  T_SERVNOTICE
345		%token  T_SET
346		%token  T_SHARED
#	Line 326 | Line 350 | reset_block_state(void)
350		%token  T_SPY
351		%token  T_SSL
352		%token  T_SSL_CIPHER_LIST
353	<	%token  T_SSL_CLIENT_METHOD
330	<	%token  T_SSL_SERVER_METHOD
331	<	%token  T_SSLV3
332	<	%token  T_TLSV1
353	>	%token  T_TARGET
354		%token  T_UMODES
355		%token  T_UNAUTH
356		%token  T_UNDLINE
#	Line 340 | Line 361 | reset_block_state(void)
361		%token  T_WALLOPS
362		%token  T_WEBIRC
363		%token  TBOOL
364	+	%token  THROTTLE_COUNT
365		%token  THROTTLE_TIME
366		%token  TKLINE_EXPIRE_NOTICES
367		%token  TMASKED
346	–	%token  TRUE_NO_OPER_FLOOD
368		%token  TS_MAX_DELTA
369		%token  TS_WARN_DELTA
370		%token  TWODOTS
371		%token  TYPE
372		%token  UNKLINE
352	–	%token  USE_EGD
373		%token  USE_LOGGING
374		%token  USER
375		%token  VHOST
376		%token  VHOST6
377	<	%token  WARN_NO_NLINE
377	>	%token  WARN_NO_CONNECT_BLOCK
378		%token  XLINE
379
380		%type  <string> QSTRING
#	Line 365 | Line 385 | reset_block_state(void)
385		%type  <number> sizespec_
386
387		%%
388	<	conf:
388	>	conf:
389		| conf conf_item
390		;
391
392		conf_item:        admin_entry
393		| logging_entry
394		| oper_entry
395	<	| channel_entry
396	<	| class_entry
395	>	| channel_entry
396	>	| class_entry
397		| listen_entry
398		| auth_entry
399		| serverinfo_entry
400	<	| serverhide_entry
400	>	| serverhide_entry
401		| resv_entry
402		| service_entry
403		| shared_entry
404	<	| cluster_entry
404	>	| cluster_entry
405		| connect_entry
406		| kill_entry
407		| deny_entry
408	<	| exempt_entry
409	<	| general_entry
408	>	| exempt_entry
409	>	| general_entry
410		| gecos_entry
411		| modules_entry
412		| motd_entry
413	+	| pseudo_entry
414		| error ';'
415		| error '}'
416		;
417
418
419		timespec_: { $$ = 0; } | timespec;
420	<	timespec:       NUMBER timespec_
421	<	{
422	<	$$ = $1 + $2;
423	<	}
424	<	| NUMBER SECONDS timespec_
425	<	{
426	<	$$ = $1 + $3;
427	<	}
428	<	| NUMBER MINUTES timespec_
429	<	{
430	<	$$ = $1 * 60 + $3;
431	<	}
432	<	| NUMBER HOURS timespec_
433	<	{
434	<	$$ = $1 * 60 * 60 + $3;
435	<	}
415	<	| NUMBER DAYS timespec_
416	<	{
417	<	$$ = $1 * 60 * 60 * 24 + $3;
418	<	}
419	<	| NUMBER WEEKS timespec_
420	<	{
421	<	$$ = $1 * 60 * 60 * 24 * 7 + $3;
422	<	}
423	<	| NUMBER MONTHS timespec_
424	<	{
425	<	$$ = $1 * 60 * 60 * 24 * 7 * 4 + $3;
426	<	}
427	<	| NUMBER YEARS timespec_
428	<	{
429	<	$$ = $1 * 60 * 60 * 24 * 365 + $3;
430	<	}
431	<	;
432	<
433	<	sizespec_:      { $$ = 0; } | sizespec;
434	<	sizespec:       NUMBER sizespec_ { $$ = $1 + $2; }
435	<	| NUMBER BYTES sizespec_ { $$ = $1 + $3; }
436	<	| NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; }
437	<	| NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
438	<	;
420	>	timespec:  NUMBER timespec_         { $$ = $1 + $2; } |
421	>	NUMBER SECONDS timespec_ { $$ = $1 + $3; } |
422	>	NUMBER MINUTES timespec_ { $$ = $1 * 60 + $3; } |
423	>	NUMBER HOURS timespec_   { $$ = $1 * 60 * 60 + $3; } |
424	>	NUMBER DAYS timespec_    { $$ = $1 * 60 * 60 * 24 + $3; } |
425	>	NUMBER WEEKS timespec_   { $$ = $1 * 60 * 60 * 24 * 7 + $3; } |
426	>	NUMBER MONTHS timespec_  { $$ = $1 * 60 * 60 * 24 * 7 * 4 + $3; } |
427	>	NUMBER YEARS timespec_   { $$ = $1 * 60 * 60 * 24 * 365 + $3; }
428	>	;
429	>
430	>	sizespec_:  { $$ = 0; } | sizespec;
431	>	sizespec:   NUMBER sizespec_ { $$ = $1 + $2; } |
432	>	NUMBER BYTES sizespec_ { $$ = $1 + $3; } |
433	>	NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; } |
434	>	NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
435	>	;
436
437
438		/***************************************************************************
#	Line 463 | Line 460 | modules_path: PATH '=' QSTRING ';'
460		serverinfo_entry: SERVERINFO '{' serverinfo_items '}' ';';
461
462		serverinfo_items:       serverinfo_items serverinfo_item | serverinfo_item ;
463	<	serverinfo_item:        serverinfo_name | serverinfo_vhost |
464	<	serverinfo_hub | serverinfo_description |
465	<	serverinfo_network_name | serverinfo_network_desc |
466	<	serverinfo_max_clients | serverinfo_max_nick_length |
467	<	serverinfo_max_topic_length | serverinfo_ssl_dh_param_file |
468	<	serverinfo_rsa_private_key_file | serverinfo_vhost6 |
469	<	serverinfo_sid | serverinfo_ssl_certificate_file |
470	<	serverinfo_ssl_client_method | serverinfo_ssl_server_method |
463	>	serverinfo_item:        serverinfo_name |
464	>	serverinfo_vhost |
465	>	serverinfo_hub |
466	>	serverinfo_description |
467	>	serverinfo_network_name |
468	>	serverinfo_network_desc |
469	>	serverinfo_max_clients |
470	>	serverinfo_max_nick_length |
471	>	serverinfo_max_topic_length |
472	>	serverinfo_ssl_dh_param_file |
473	>	serverinfo_ssl_dh_elliptic_curve |
474	>	serverinfo_rsa_private_key_file |
475	>	serverinfo_vhost6 |
476	>	serverinfo_sid |
477	>	serverinfo_ssl_certificate_file |
478		serverinfo_ssl_cipher_list |
479	<	error ';' ;
480	<
477	<
478	<	serverinfo_ssl_client_method: T_SSL_CLIENT_METHOD '=' client_method_types ';' ;
479	<	serverinfo_ssl_server_method: T_SSL_SERVER_METHOD '=' server_method_types ';' ;
480	<
481	<	client_method_types: client_method_types ',' client_method_type_item | client_method_type_item;
482	<	client_method_type_item: T_SSLV3
483	<	{
484	<	#ifdef HAVE_LIBCRYPTO
485	<	if (conf_parser_ctx.pass == 2 && ServerInfo.client_ctx)
486	<	SSL_CTX_clear_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv3);
487	<	#endif
488	<	} | T_TLSV1
489	<	{
490	<	#ifdef HAVE_LIBCRYPTO
491	<	if (conf_parser_ctx.pass == 2 && ServerInfo.client_ctx)
492	<	SSL_CTX_clear_options(ServerInfo.client_ctx, SSL_OP_NO_TLSv1);
493	<	#endif
494	<	};
479	>	serverinfo_ssl_message_digest_algorithm |
480	>	error ';' ;
481
496	–	server_method_types: server_method_types ',' server_method_type_item | server_method_type_item;
497	–	server_method_type_item: T_SSLV3
498	–	{
499	–	#ifdef HAVE_LIBCRYPTO
500	–	if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
501	–	SSL_CTX_clear_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv3);
502	–	#endif
503	–	} | T_TLSV1
504	–	{
505	–	#ifdef HAVE_LIBCRYPTO
506	–	if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
507	–	SSL_CTX_clear_options(ServerInfo.server_ctx, SSL_OP_NO_TLSv1);
508	–	#endif
509	–	};
482
483		serverinfo_ssl_certificate_file: SSL_CERTIFICATE_FILE '=' QSTRING ';'
484		{
485		#ifdef HAVE_LIBCRYPTO
486	<	if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
486	>	if (conf_parser_ctx.pass == 2)
487		{
488	<	if (!ServerInfo.rsa_private_key_file)
488	>	if (!ConfigServerInfo.rsa_private_key_file)
489		{
490		conf_error_report("No rsa_private_key_file specified, SSL disabled");
491		break;
492		}
493
494	<	if (SSL_CTX_use_certificate_file(ServerInfo.server_ctx, yylval.string,
495	<	SSL_FILETYPE_PEM) <= 0 ||
524	<	SSL_CTX_use_certificate_file(ServerInfo.client_ctx, yylval.string,
525	<	SSL_FILETYPE_PEM) <= 0)
494	>	if (SSL_CTX_use_certificate_chain_file(ConfigServerInfo.server_ctx, yylval.string) <= 0 ||
495	>	SSL_CTX_use_certificate_chain_file(ConfigServerInfo.client_ctx, yylval.string) <= 0)
496		{
497		report_crypto_errors();
498		conf_error_report("Could not open/read certificate file");
499		break;
500		}
501
502	<	if (SSL_CTX_use_PrivateKey_file(ServerInfo.server_ctx, ServerInfo.rsa_private_key_file,
502	>	if (SSL_CTX_use_PrivateKey_file(ConfigServerInfo.server_ctx, ConfigServerInfo.rsa_private_key_file,
503		SSL_FILETYPE_PEM) <= 0 ||
504	<	SSL_CTX_use_PrivateKey_file(ServerInfo.client_ctx, ServerInfo.rsa_private_key_file,
504	>	SSL_CTX_use_PrivateKey_file(ConfigServerInfo.client_ctx, ConfigServerInfo.rsa_private_key_file,
505		SSL_FILETYPE_PEM) <= 0)
506		{
507		report_crypto_errors();
#	Line 539 | Line 509 | serverinfo_ssl_certificate_file: SSL_CER
509		break;
510		}
511
512	<	if (!SSL_CTX_check_private_key(ServerInfo.server_ctx) ||
513	<	!SSL_CTX_check_private_key(ServerInfo.client_ctx))
512	>	if (!SSL_CTX_check_private_key(ConfigServerInfo.server_ctx) ||
513	>	!SSL_CTX_check_private_key(ConfigServerInfo.client_ctx))
514		{
515		report_crypto_errors();
516		conf_error_report("Could not read RSA private key");
#	Line 558 | Line 528 | serverinfo_rsa_private_key_file: RSA_PRI
528		if (conf_parser_ctx.pass != 1)
529		break;
530
531	<	if (ServerInfo.rsa_private_key)
531	>	if (ConfigServerInfo.rsa_private_key)
532		{
533	<	RSA_free(ServerInfo.rsa_private_key);
534	<	ServerInfo.rsa_private_key = NULL;
533	>	RSA_free(ConfigServerInfo.rsa_private_key);
534	>	ConfigServerInfo.rsa_private_key = NULL;
535		}
536
537	<	if (ServerInfo.rsa_private_key_file)
537	>	if (ConfigServerInfo.rsa_private_key_file)
538		{
539	<	MyFree(ServerInfo.rsa_private_key_file);
540	<	ServerInfo.rsa_private_key_file = NULL;
539	>	MyFree(ConfigServerInfo.rsa_private_key_file);
540	>	ConfigServerInfo.rsa_private_key_file = NULL;
541		}
542
543	<	ServerInfo.rsa_private_key_file = xstrdup(yylval.string);
543	>	ConfigServerInfo.rsa_private_key_file = xstrdup(yylval.string);
544
545		if ((file = BIO_new_file(yylval.string, "r")) == NULL)
546		{
#	Line 578 | Line 548 | serverinfo_rsa_private_key_file: RSA_PRI
548		break;
549		}
550
551	<	ServerInfo.rsa_private_key = PEM_read_bio_RSAPrivateKey(file, NULL, 0, NULL);
551	>	ConfigServerInfo.rsa_private_key = PEM_read_bio_RSAPrivateKey(file, NULL, 0, NULL);
552
553		BIO_set_close(file, BIO_CLOSE);
554		BIO_free(file);
555
556	<	if (ServerInfo.rsa_private_key == NULL)
556	>	if (ConfigServerInfo.rsa_private_key == NULL)
557		{
558		conf_error_report("Couldn't extract key, ignoring");
559		break;
560		}
561
562	<	if (!RSA_check_key(ServerInfo.rsa_private_key))
562	>	if (!RSA_check_key(ConfigServerInfo.rsa_private_key))
563		{
564	<	RSA_free(ServerInfo.rsa_private_key);
565	<	ServerInfo.rsa_private_key = NULL;
564	>	RSA_free(ConfigServerInfo.rsa_private_key);
565	>	ConfigServerInfo.rsa_private_key = NULL;
566
567		conf_error_report("Invalid key, ignoring");
568		break;
569		}
570
571	<	/* require 2048 bit (256 byte) key */
602	<	if (RSA_size(ServerInfo.rsa_private_key) != 256)
571	>	if (RSA_size(ConfigServerInfo.rsa_private_key) < 128)
572		{
573	<	RSA_free(ServerInfo.rsa_private_key);
574	<	ServerInfo.rsa_private_key = NULL;
573	>	RSA_free(ConfigServerInfo.rsa_private_key);
574	>	ConfigServerInfo.rsa_private_key = NULL;
575
576	<	conf_error_report("Not a 2048 bit key, ignoring");
576	>	conf_error_report("Ignoring serverinfo::rsa_private_key_file -- need at least a 1024 bit key size");
577		}
578		#endif
579		};
580
581		serverinfo_ssl_dh_param_file: SSL_DH_PARAM_FILE '=' QSTRING ';'
582		{
614	–	/* TBD - XXX: error reporting */
583		#ifdef HAVE_LIBCRYPTO
584	<	if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
584	>	if (conf_parser_ctx.pass == 2)
585		{
586		BIO *file = BIO_new_file(yylval.string, "r");
587
#	Line 628 | Line 596 | serverinfo_ssl_dh_param_file: SSL_DH_PAR
596		if (DH_size(dh) < 128)
597		conf_error_report("Ignoring serverinfo::ssl_dh_param_file -- need at least a 1024 bit DH prime size");
598		else
599	<	SSL_CTX_set_tmp_dh(ServerInfo.server_ctx, dh);
599	>	SSL_CTX_set_tmp_dh(ConfigServerInfo.server_ctx, dh);
600
601		DH_free(dh);
602		}
603		}
604	+	else
605	+	conf_error_report("Ignoring serverinfo::ssl_dh_param_file -- could not open/read Diffie-Hellman parameter file");
606		}
607		#endif
608		};
#	Line 640 | Line 610 | serverinfo_ssl_dh_param_file: SSL_DH_PAR
610		serverinfo_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
611		{
612		#ifdef HAVE_LIBCRYPTO
613	<	if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
614	<	SSL_CTX_set_cipher_list(ServerInfo.server_ctx, yylval.string);
613	>	if (conf_parser_ctx.pass == 2)
614	>	SSL_CTX_set_cipher_list(ConfigServerInfo.server_ctx, yylval.string);
615	>	#endif
616	>	};
617	>
618	>	serverinfo_ssl_message_digest_algorithm: SSL_MESSAGE_DIGEST_ALGORITHM '=' QSTRING ';'
619	>	{
620	>	#ifdef HAVE_LIBCRYPTO
621	>	if (conf_parser_ctx.pass == 2)
622	>	{
623	>	if ((ConfigServerInfo.message_digest_algorithm = EVP_get_digestbyname(yylval.string)) == NULL)
624	>	{
625	>	ConfigServerInfo.message_digest_algorithm = EVP_sha256();
626	>	conf_error_report("Ignoring serverinfo::ssl_message_digest_algorithm -- unknown message digest algorithm");
627	>	}
628	>	}
629	>	#endif
630	>	}
631	>
632	>	serverinfo_ssl_dh_elliptic_curve: SSL_DH_ELLIPTIC_CURVE '=' QSTRING ';'
633	>	{
634	>	#ifdef HAVE_LIBCRYPTO
635	>	#if OPENSSL_VERSION_NUMBER >= 0x009080FFL && !defined(OPENSSL_NO_ECDH)
636	>	int nid = 0;
637	>	EC_KEY *key = NULL;
638	>
639	>	if (conf_parser_ctx.pass == 2)
640	>	{
641	>	if ((nid = OBJ_sn2nid(yylval.string)) == 0)
642	>	{
643	>	conf_error_report("Ignoring serverinfo::serverinfo_ssl_dh_elliptic_curve -- unknown curve name");
644	>	break;
645	>	}
646	>
647	>	if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)
648	>	{
649	>	conf_error_report("Ignoring serverinfo::serverinfo_ssl_dh_elliptic_curve -- could not create curve");
650	>	break;
651	>	}
652	>
653	>	SSL_CTX_set_tmp_ecdh(ConfigServerInfo.server_ctx, key);
654	>	EC_KEY_free(key);
655	>	}
656	>	#endif
657		#endif
658		};
659
660	<	serverinfo_name: NAME '=' QSTRING ';'
660	>	serverinfo_name: NAME '=' QSTRING ';'
661		{
662		/* this isn't rehashable */
663	<	if (conf_parser_ctx.pass == 2 && !ServerInfo.name)
663	>	if (conf_parser_ctx.pass == 2 && !ConfigServerInfo.name)
664		{
665		if (valid_servname(yylval.string))
666	<	ServerInfo.name = xstrdup(yylval.string);
666	>	ConfigServerInfo.name = xstrdup(yylval.string);
667		else
668		{
669		conf_error_report("Ignoring serverinfo::name -- invalid name. Aborting.");
#	Line 660 | Line 672 | serverinfo_name: NAME '=' QSTRING ';'
672		}
673		};
674
675	<	serverinfo_sid: IRCD_SID '=' QSTRING ';'
675	>	serverinfo_sid: IRCD_SID '=' QSTRING ';'
676		{
677		/* this isn't rehashable */
678	<	if (conf_parser_ctx.pass == 2 && !ServerInfo.sid)
678	>	if (conf_parser_ctx.pass == 2 && !ConfigServerInfo.sid)
679		{
680		if (valid_sid(yylval.string))
681	<	ServerInfo.sid = xstrdup(yylval.string);
681	>	ConfigServerInfo.sid = xstrdup(yylval.string);
682		else
683		{
684		conf_error_report("Ignoring serverinfo::sid -- invalid SID. Aborting.");
#	Line 679 | Line 691 | serverinfo_description: DESCRIPTION '='
691		{
692		if (conf_parser_ctx.pass == 2)
693		{
694	<	MyFree(ServerInfo.description);
695	<	ServerInfo.description = xstrdup(yylval.string);
694	>	MyFree(ConfigServerInfo.description);
695	>	ConfigServerInfo.description = xstrdup(yylval.string);
696	>	strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
697		}
698		};
699
#	Line 690 | Line 703 | serverinfo_network_name: NETWORK_NAME '=
703		{
704		char *p;
705
706	<	if ((p = strchr(yylval.string, ' ')) != NULL)
707	<	p = '\0';
706	>	if ((p = strchr(yylval.string, ' ')))
707	>	*p = '\0';
708
709	<	MyFree(ServerInfo.network_name);
710	<	ServerInfo.network_name = xstrdup(yylval.string);
709	>	MyFree(ConfigServerInfo.network_name);
710	>	ConfigServerInfo.network_name = xstrdup(yylval.string);
711		}
712		};
713
#	Line 703 | Line 716 | serverinfo_network_desc: NETWORK_DESC '=
716		if (conf_parser_ctx.pass != 2)
717		break;
718
719	<	MyFree(ServerInfo.network_desc);
720	<	ServerInfo.network_desc = xstrdup(yylval.string);
719	>	MyFree(ConfigServerInfo.network_desc);
720	>	ConfigServerInfo.network_desc = xstrdup(yylval.string);
721		};
722
723		serverinfo_vhost: VHOST '=' QSTRING ';'
#	Line 723 | Line 736 | serverinfo_vhost: VHOST '=' QSTRING ';'
736		ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
737		else
738		{
739	<	assert(res != NULL);
739	>	assert(res);
740
741	<	memcpy(&ServerInfo.ip, res->ai_addr, res->ai_addrlen);
742	<	ServerInfo.ip.ss.ss_family = res->ai_family;
743	<	ServerInfo.ip.ss_len = res->ai_addrlen;
741	>	memcpy(&ConfigServerInfo.ip, res->ai_addr, res->ai_addrlen);
742	>	ConfigServerInfo.ip.ss.ss_family = res->ai_family;
743	>	ConfigServerInfo.ip.ss_len = res->ai_addrlen;
744		freeaddrinfo(res);
745
746	<	ServerInfo.specific_ipv4_vhost = 1;
746	>	ConfigServerInfo.specific_ipv4_vhost = 1;
747		}
748		}
749		};
750
751		serverinfo_vhost6: VHOST6 '=' QSTRING ';'
752		{
740	–	#ifdef IPV6
753		if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
754		{
755		struct addrinfo hints, *res;
#	Line 752 | Line 764 | serverinfo_vhost6: VHOST6 '=' QSTRING ';
764		ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost6(%s)", yylval.string);
765		else
766		{
767	<	assert(res != NULL);
767	>	assert(res);
768
769	<	memcpy(&ServerInfo.ip6, res->ai_addr, res->ai_addrlen);
770	<	ServerInfo.ip6.ss.ss_family = res->ai_family;
771	<	ServerInfo.ip6.ss_len = res->ai_addrlen;
769	>	memcpy(&ConfigServerInfo.ip6, res->ai_addr, res->ai_addrlen);
770	>	ConfigServerInfo.ip6.ss.ss_family = res->ai_family;
771	>	ConfigServerInfo.ip6.ss_len = res->ai_addrlen;
772		freeaddrinfo(res);
773
774	<	ServerInfo.specific_ipv6_vhost = 1;
774	>	ConfigServerInfo.specific_ipv6_vhost = 1;
775		}
776		}
765	–	#endif
777		};
778
779		serverinfo_max_clients: T_MAX_CLIENTS '=' NUMBER ';'
#	Line 772 | Line 783 | serverinfo_max_clients: T_MAX_CLIENTS '=
783
784		if ($3 < MAXCLIENTS_MIN)
785		{
786	<	char buf[IRCD_BUFSIZE];
786	>	char buf[IRCD_BUFSIZE] = "";
787
788		snprintf(buf, sizeof(buf), "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
789		conf_error_report(buf);
790	<	ServerInfo.max_clients = MAXCLIENTS_MIN;
790	>	ConfigServerInfo.max_clients = MAXCLIENTS_MIN;
791		}
792		else if ($3 > MAXCLIENTS_MAX)
793		{
794	<	char buf[IRCD_BUFSIZE];
794	>	char buf[IRCD_BUFSIZE] = "";
795
796		snprintf(buf, sizeof(buf), "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
797		conf_error_report(buf);
798	<	ServerInfo.max_clients = MAXCLIENTS_MAX;
798	>	ConfigServerInfo.max_clients = MAXCLIENTS_MAX;
799		}
800		else
801	<	ServerInfo.max_clients = $3;
801	>	ConfigServerInfo.max_clients = $3;
802		};
803
804		serverinfo_max_nick_length: MAX_NICK_LENGTH '=' NUMBER ';'
#	Line 798 | Line 809 | serverinfo_max_nick_length: MAX_NICK_LEN
809		if ($3 < 9)
810		{
811		conf_error_report("max_nick_length too low, setting to 9");
812	<	ServerInfo.max_nick_length = 9;
812	>	ConfigServerInfo.max_nick_length = 9;
813		}
814		else if ($3 > NICKLEN)
815		{
816	<	char buf[IRCD_BUFSIZE];
816	>	char buf[IRCD_BUFSIZE] = "";
817
818		snprintf(buf, sizeof(buf), "max_nick_length too high, setting to %d", NICKLEN);
819		conf_error_report(buf);
820	<	ServerInfo.max_nick_length = NICKLEN;
820	>	ConfigServerInfo.max_nick_length = NICKLEN;
821		}
822		else
823	<	ServerInfo.max_nick_length = $3;
823	>	ConfigServerInfo.max_nick_length = $3;
824		};
825
826		serverinfo_max_topic_length: MAX_TOPIC_LENGTH '=' NUMBER ';'
#	Line 820 | Line 831 | serverinfo_max_topic_length: MAX_TOPIC_L
831		if ($3 < 80)
832		{
833		conf_error_report("max_topic_length too low, setting to 80");
834	<	ServerInfo.max_topic_length = 80;
834	>	ConfigServerInfo.max_topic_length = 80;
835		}
836		else if ($3 > TOPICLEN)
837		{
838	<	char buf[IRCD_BUFSIZE];
838	>	char buf[IRCD_BUFSIZE] = "";
839
840		snprintf(buf, sizeof(buf), "max_topic_length too high, setting to %d", TOPICLEN);
841		conf_error_report(buf);
842	<	ServerInfo.max_topic_length = TOPICLEN;
842	>	ConfigServerInfo.max_topic_length = TOPICLEN;
843		}
844		else
845	<	ServerInfo.max_topic_length = $3;
845	>	ConfigServerInfo.max_topic_length = $3;
846		};
847
848	<	serverinfo_hub: HUB '=' TBOOL ';'
848	>	serverinfo_hub: HUB '=' TBOOL ';'
849		{
850		if (conf_parser_ctx.pass == 2)
851	<	ServerInfo.hub = yylval.number;
851	>	ConfigServerInfo.hub = yylval.number;
852		};
853
854		/***************************************************************************
#	Line 846 | Line 857 | serverinfo_hub: HUB '=' TBOOL ';'
857		admin_entry: ADMIN  '{' admin_items '}' ';' ;
858
859		admin_items: admin_items admin_item | admin_item;
860	<	admin_item:  admin_name | admin_description |
861	<	admin_email | error ';' ;
860	>	admin_item:  admin_name |
861	>	admin_description |
862	>	admin_email |
863	>	error ';' ;
864
865	<	admin_name: NAME '=' QSTRING ';'
865	>	admin_name: NAME '=' QSTRING ';'
866		{
867		if (conf_parser_ctx.pass != 2)
868		break;
869
870	<	MyFree(AdminInfo.name);
871	<	AdminInfo.name = xstrdup(yylval.string);
870	>	MyFree(ConfigAdminInfo.name);
871	>	ConfigAdminInfo.name = xstrdup(yylval.string);
872		};
873
874		admin_email: EMAIL '=' QSTRING ';'
#	Line 863 | Line 876 | admin_email: EMAIL '=' QSTRING ';'
876		if (conf_parser_ctx.pass != 2)
877		break;
878
879	<	MyFree(AdminInfo.email);
880	<	AdminInfo.email = xstrdup(yylval.string);
879	>	MyFree(ConfigAdminInfo.email);
880	>	ConfigAdminInfo.email = xstrdup(yylval.string);
881		};
882
883		admin_description: DESCRIPTION '=' QSTRING ';'
#	Line 872 | Line 885 | admin_description: DESCRIPTION '=' QSTRI
885		if (conf_parser_ctx.pass != 2)
886		break;
887
888	<	MyFree(AdminInfo.description);
889	<	AdminInfo.description = xstrdup(yylval.string);
888	>	MyFree(ConfigAdminInfo.description);
889	>	ConfigAdminInfo.description = xstrdup(yylval.string);
890		};
891
892		/***************************************************************************
893		* motd section
894		***************************************************************************/
895	<	motd_entry: MOTD
895	>	motd_entry: MOTD
896		{
897		if (conf_parser_ctx.pass == 2)
898		reset_block_state();
899		} '{' motd_items '}' ';'
900		{
901	<	dlink_node *ptr = NULL;
901	>	dlink_node *node = NULL;
902
903		if (conf_parser_ctx.pass != 2)
904		break;
#	Line 893 | Line 906 | motd_entry: MOTD
906		if (!block_state.file.buf[0])
907		break;
908
909	<	DLINK_FOREACH(ptr, block_state.mask.list.head)
910	<	motd_add(ptr->data, block_state.file.buf);
909	>	DLINK_FOREACH(node, block_state.mask.list.head)
910	>	motd_add(node->data, block_state.file.buf);
911		};
912
913		motd_items: motd_items motd_item | motd_item;
914		motd_item:  motd_mask | motd_file | error ';' ;
915
916	<	motd_mask: MASK '=' QSTRING ';'
916	>	motd_mask: MASK '=' QSTRING ';'
917		{
918		if (conf_parser_ctx.pass == 2)
919		dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
#	Line 913 | Line 926 | motd_file: T_FILE '=' QSTRING ';'
926		};
927
928		/***************************************************************************
929	+	* pseudo section
930	+	***************************************************************************/
931	+	pseudo_entry: T_PSEUDO
932	+	{
933	+	if (conf_parser_ctx.pass == 2)
934	+	reset_block_state();
935	+	} '{' pseudo_items '}' ';'
936	+	{
937	+	if (conf_parser_ctx.pass != 2)
938	+	break;
939	+
940	+	if (!block_state.command.buf[0] ||
941	+	!block_state.name.buf[0] ||
942	+	!block_state.nick.buf[0] ||
943	+	!block_state.host.buf[0])
944	+	break;
945	+
946	+	pseudo_register(block_state.name.buf, block_state.nick.buf, block_state.host.buf,
947	+	block_state.prepend.buf, block_state.command.buf);
948	+	};
949	+
950	+	pseudo_items: pseudo_items pseudo_item | pseudo_item;
951	+	pseudo_item:  pseudo_command | pseudo_prepend | pseudo_name | pseudo_target | error ';' ;
952	+
953	+	pseudo_command: T_COMMAND '=' QSTRING ';'
954	+	{
955	+	if (conf_parser_ctx.pass == 2)
956	+	strlcpy(block_state.command.buf, yylval.string, sizeof(block_state.command.buf));
957	+	};
958	+
959	+	pseudo_name: NAME '=' QSTRING ';'
960	+	{
961	+	if (conf_parser_ctx.pass == 2)
962	+	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
963	+	};
964	+
965	+	pseudo_prepend: T_PREPEND '=' QSTRING ';'
966	+	{
967	+	if (conf_parser_ctx.pass == 2)
968	+	strlcpy(block_state.prepend.buf, yylval.string, sizeof(block_state.prepend.buf));
969	+	};
970	+
971	+	pseudo_target: T_TARGET '=' QSTRING ';'
972	+	{
973	+	if (conf_parser_ctx.pass == 2)
974	+	{
975	+	struct split_nuh_item nuh;
976	+
977	+	nuh.nuhmask  = yylval.string;
978	+	nuh.nickptr  = NULL;
979	+	nuh.userptr  = block_state.user.buf;
980	+	nuh.hostptr  = block_state.host.buf;
981	+	nuh.nicksize = 0;
982	+	nuh.usersize = sizeof(block_state.nick.buf);
983	+	nuh.hostsize = sizeof(block_state.host.buf);
984	+	split_nuh(&nuh);
985	+
986	+	strlcpy(block_state.nick.buf, nuh.userptr, sizeof(block_state.nick.buf));
987	+	strlcpy(block_state.host.buf, nuh.hostptr, sizeof(block_state.host.buf));
988	+	}
989	+	};
990	+
991	+	/***************************************************************************
992		*  section logging
993		***************************************************************************/
994		logging_entry:          T_LOG  '{' logging_items '}' ';' ;
995		logging_items:          logging_items logging_item | logging_item ;
996
997	<	logging_item:           logging_use_logging | logging_file_entry |
998	<	error ';' ;
997	>	logging_item:           logging_use_logging | logging_file_entry |
998	>	error ';' ;
999
1000		logging_use_logging: USE_LOGGING '=' TBOOL ';'
1001		{
1002		if (conf_parser_ctx.pass == 2)
1003	<	ConfigLoggingEntry.use_logging = yylval.number;
1003	>	ConfigLog.use_logging = yylval.number;
1004		};
1005
1006		logging_file_entry:
#	Line 982 | Line 1058 | logging_file_type_item:  USER
1058		{
1059		if (conf_parser_ctx.pass == 2)
1060		block_state.type.value = LOG_TYPE_GLINE;
1061	+	} | XLINE
1062	+	{
1063	+	if (conf_parser_ctx.pass == 2)
1064	+	block_state.type.value = LOG_TYPE_XLINE;
1065	+	} | RESV
1066	+	{
1067	+	if (conf_parser_ctx.pass == 2)
1068	+	block_state.type.value = LOG_TYPE_RESV;
1069		} | T_DLINE
1070		{
1071		if (conf_parser_ctx.pass == 2)
#	Line 1004 | Line 1088 | logging_file_type_item:  USER
1088		/***************************************************************************
1089		* section oper
1090		***************************************************************************/
1091	<	oper_entry: OPERATOR
1091	>	oper_entry: OPERATOR
1092		{
1093		if (conf_parser_ctx.pass != 2)
1094		break;
#	Line 1013 | Line 1097 | oper_entry: OPERATOR
1097		block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
1098		} '{' oper_items '}' ';'
1099		{
1100	<	dlink_node *ptr = NULL;
1100	>	dlink_node *node = NULL;
1101
1102		if (conf_parser_ctx.pass != 2)
1103		break;
#	Line 1029 | Line 1113 | oper_entry: OPERATOR
1113		break;
1114		#endif
1115
1116	<	DLINK_FOREACH(ptr, block_state.mask.list.head)
1116	>	DLINK_FOREACH(node, block_state.mask.list.head)
1117		{
1118		struct MaskItem *conf = NULL;
1119		struct split_nuh_item nuh;
1120
1121	<	nuh.nuhmask  = ptr->data;
1121	>	nuh.nuhmask  = node->data;
1122		nuh.nickptr  = NULL;
1123		nuh.userptr  = block_state.user.buf;
1124		nuh.hostptr  = block_state.host.buf;
#	Line 1069 | Line 1153 | oper_entry: OPERATOR
1153
1154		if ((file = BIO_new_file(block_state.file.buf, "r")) == NULL)
1155		{
1156	<	conf_error_report("Ignoring rsa_public_key_file -- file doesn't exist");
1156	>	ilog(LOG_TYPE_IRCD, "Ignoring rsa_public_key_file -- file doesn't exist");
1157		break;
1158		}
1159
1160		if ((pkey = PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL)) == NULL)
1161	<	conf_error_report("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
1161	>	ilog(LOG_TYPE_IRCD, "Ignoring rsa_public_key_file -- key invalid; check key syntax");
1162	>	else
1163	>	{
1164	>	if (RSA_size(pkey) > 128)
1165	>	ilog(LOG_TYPE_IRCD, "Ignoring rsa_public_key_file -- key size must be 1024 or below");
1166	>	else
1167	>	conf->rsa_public_key = pkey;
1168	>	}
1169
1079	–	conf->rsa_public_key = pkey;
1170		BIO_set_close(file, BIO_CLOSE);
1171		BIO_free(file);
1172		}
#	Line 1085 | Line 1175 | oper_entry: OPERATOR
1175		};
1176
1177		oper_items:     oper_items oper_item | oper_item;
1178	<	oper_item:      oper_name | oper_user | oper_password |
1179	<	oper_umodes | oper_class | oper_encrypted |
1180	<	oper_rsa_public_key_file | oper_ssl_certificate_fingerprint |
1181	<	oper_ssl_connection_required |
1182	<	oper_flags | error ';' ;
1178	>	oper_item:      oper_name |
1179	>	oper_user |
1180	>	oper_password |
1181	>	oper_umodes |
1182	>	oper_class |
1183	>	oper_encrypted |
1184	>	oper_rsa_public_key_file |
1185	>	oper_ssl_certificate_fingerprint |
1186	>	oper_ssl_connection_required |
1187	>	oper_flags |
1188	>	error ';' ;
1189
1190		oper_name: NAME '=' QSTRING ';'
1191		{
#	Line 1180 | Line 1276 | oper_umodes_item:  T_BOTS
1276		{
1277		if (conf_parser_ctx.pass == 2)
1278		block_state.modes.value |= UMODE_HIDDEN;
1279	+	} | HIDE_CHANS
1280	+	{
1281	+	if (conf_parser_ctx.pass == 2)
1282	+	block_state.modes.value |= UMODE_HIDECHANS;
1283	+	} | HIDE_IDLE
1284	+	{
1285	+	if (conf_parser_ctx.pass == 2)
1286	+	block_state.modes.value |= UMODE_HIDEIDLE;
1287		} | T_SKILL
1288		{
1289		if (conf_parser_ctx.pass == 2)
#	Line 1204 | Line 1308 | oper_umodes_item:  T_BOTS
1308		{
1309		if (conf_parser_ctx.pass == 2)
1310		block_state.modes.value |= UMODE_EXTERNAL;
1207	–	} | T_OPERWALL
1208	–	{
1209	–	if (conf_parser_ctx.pass == 2)
1210	–	block_state.modes.value |= UMODE_OPERWALL;
1311		} | T_SERVNOTICE
1312		{
1313		if (conf_parser_ctx.pass == 2)
#	Line 1276 | Line 1376 | oper_flags_item: KILL ':' REMOTE
1376		} | KLINE
1377		{
1378		if (conf_parser_ctx.pass == 2)
1379	<	block_state.port.value |= OPER_FLAG_K;
1379	>	block_state.port.value |= OPER_FLAG_KLINE;
1380		} | UNKLINE
1381		{
1382		if (conf_parser_ctx.pass == 2)
#	Line 1292 | Line 1392 | oper_flags_item: KILL ':' REMOTE
1392		} | XLINE
1393		{
1394		if (conf_parser_ctx.pass == 2)
1395	<	block_state.port.value |= OPER_FLAG_X;
1395	>	block_state.port.value |= OPER_FLAG_XLINE;
1396	>	} | T_UNXLINE
1397	>	{
1398	>	if (conf_parser_ctx.pass == 2)
1399	>	block_state.port.value |= OPER_FLAG_UNXLINE;
1400		} | GLINE
1401		{
1402		if (conf_parser_ctx.pass == 2)
#	Line 1313 | Line 1417 | oper_flags_item: KILL ':' REMOTE
1417		{
1418		if (conf_parser_ctx.pass == 2)
1419		block_state.port.value |= OPER_FLAG_ADMIN;
1316	–	} | T_OPERWALL
1317	–	{
1318	–	if (conf_parser_ctx.pass == 2)
1319	–	block_state.port.value |= OPER_FLAG_OPERWALL;
1420		} | T_GLOBOPS
1421		{
1422		if (conf_parser_ctx.pass == 2)
#	Line 1341 | Line 1441 | oper_flags_item: KILL ':' REMOTE
1441		{
1442		if (conf_parser_ctx.pass == 2)
1443		block_state.port.value |= OPER_FLAG_MODULE;
1444	+	} | T_OPME
1445	+	{
1446	+	if (conf_parser_ctx.pass == 2)
1447	+	block_state.port.value |= OPER_FLAG_OPME;
1448		};
1449
1450
#	Line 1384 | Line 1488 | class_entry: CLASS
1488		class->max_ident = block_state.max_ident.value;
1489		class->max_sendq = block_state.max_sendq.value;
1490		class->max_recvq = block_state.max_recvq.value;
1491	+	class->max_channels = block_state.max_channels.value;
1492
1493		if (block_state.min_idle.value > block_state.max_idle.value)
1494		{
#	Line 1410 | Line 1515 | class_entry: CLASS
1515
1516		class_items:    class_items class_item | class_item;
1517		class_item:     class_name |
1518	<	class_cidr_bitlen_ipv4 | class_cidr_bitlen_ipv6 |
1518	>	class_cidr_bitlen_ipv4 |
1519	>	class_cidr_bitlen_ipv6 |
1520		class_ping_time |
1521	<	class_number_per_cidr |
1521	>	class_number_per_cidr |
1522		class_number_per_ip |
1523		class_connectfreq |
1524	+	class_max_channels |
1525		class_max_number |
1526	<	class_max_global |
1527	<	class_max_local |
1528	<	class_max_ident |
1526	>	class_max_global |
1527	>	class_max_local |
1528	>	class_max_ident |
1529		class_sendq | class_recvq |
1530		class_min_idle |
1531		class_max_idle |
1532		class_flags |
1533	<	error ';' ;
1533	>	error ';' ;
1534
1535	<	class_name: NAME '=' QSTRING ';'
1535	>	class_name: NAME '=' QSTRING ';'
1536		{
1537		if (conf_parser_ctx.pass == 1)
1538		strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
#	Line 1449 | Line 1556 | class_connectfreq: CONNECTFREQ '=' times
1556		block_state.con_freq.value = $3;
1557		};
1558
1559	+	class_max_channels: MAX_CHANNELS '=' NUMBER ';'
1560	+	{
1561	+	if (conf_parser_ctx.pass == 1)
1562	+	block_state.max_channels.value = $3;
1563	+	};
1564	+
1565		class_max_number: MAX_NUMBER '=' NUMBER ';'
1566		{
1567		if (conf_parser_ctx.pass == 1)
#	Line 1580 | Line 1693 | port_item: NUMBER
1693		{
1694		if (conf_parser_ctx.pass == 2)
1695		{
1696	+	#ifndef HAVE_LIBCRYPTO
1697		if (block_state.flags.value & LISTENER_SSL)
1698	<	#ifdef HAVE_LIBCRYPTO
1699	<	if (!ServerInfo.server_ctx)
1698	>	{
1699	>	conf_error_report("SSL not available - port closed");
1700	>	break;
1701	>	}
1702		#endif
1587	–	{
1588	–	conf_error_report("SSL not available - port closed");
1589	–	break;
1590	–	}
1703		add_listener($1, block_state.addr.buf, block_state.flags.value);
1704		}
1705		} | NUMBER TWODOTS NUMBER
1706		{
1707		if (conf_parser_ctx.pass == 2)
1708		{
1709	<	int i;
1598	<
1709	>	#ifndef HAVE_LIBCRYPTO
1710		if (block_state.flags.value & LISTENER_SSL)
1711	<	#ifdef HAVE_LIBCRYPTO
1712	<	if (!ServerInfo.server_ctx)
1711	>	{
1712	>	conf_error_report("SSL not available - port closed");
1713	>	break;
1714	>	}
1715		#endif
1603	–	{
1604	–	conf_error_report("SSL not available - port closed");
1605	–	break;
1606	–	}
1716
1717	<	for (i = $1; i <= $3; ++i)
1717	>	for (int i = $1; i <= $3; ++i)
1718		add_listener(i, block_state.addr.buf, block_state.flags.value);
1719		}
1720		};
#	Line 1631 | Line 1740 | auth_entry: IRCD_AUTH
1740		reset_block_state();
1741		} '{' auth_items '}' ';'
1742		{
1743	<	dlink_node *ptr = NULL;
1743	>	dlink_node *node = NULL;
1744
1745		if (conf_parser_ctx.pass != 2)
1746		break;
1747
1748	<	DLINK_FOREACH(ptr, block_state.mask.list.head)
1748	>	DLINK_FOREACH(node, block_state.mask.list.head)
1749		{
1750		struct MaskItem *conf = NULL;
1751		struct split_nuh_item nuh;
1752
1753	<	nuh.nuhmask  = ptr->data;
1753	>	nuh.nuhmask  = node->data;
1754		nuh.nickptr  = NULL;
1755		nuh.userptr  = block_state.user.buf;
1756		nuh.hostptr  = block_state.host.buf;
#	Line 1665 | Line 1774 | auth_entry: IRCD_AUTH
1774		conf_add_class_to_conf(conf, block_state.class.buf);
1775		add_conf_by_address(CONF_CLIENT, conf);
1776		}
1777	<	};
1777	>	};
1778
1779		auth_items:     auth_items auth_item | auth_item;
1780	<	auth_item:      auth_user | auth_passwd | auth_class | auth_flags |
1781	<	auth_spoof | auth_redir_serv | auth_redir_port |
1782	<	auth_encrypted | error ';' ;
1780	>	auth_item:      auth_user |
1781	>	auth_passwd |
1782	>	auth_class |
1783	>	auth_flags |
1784	>	auth_spoof |
1785	>	auth_redir_serv |
1786	>	auth_redir_port |
1787	>	auth_encrypted |
1788	>	error ';' ;
1789
1790		auth_user: USER '=' QSTRING ';'
1791		{
#	Line 1750 | Line 1865 | auth_flags_item: SPOOF_NOTICE
1865		block_state.flags.value |= CONF_FLAGS_NEED_PASSWORD;
1866		};
1867
1868	<	auth_spoof: SPOOF '=' QSTRING ';'
1868	>	auth_spoof: SPOOF '=' QSTRING ';'
1869		{
1870		if (conf_parser_ctx.pass != 2)
1871		break;
1872
1873	<	if (strlen(yylval.string) <= HOSTLEN && valid_hostname(yylval.string))
1873	>	if (valid_hostname(yylval.string))
1874		{
1875		strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
1876		block_state.flags.value |= CONF_FLAGS_SPOOF_IP;
#	Line 1801 | Line 1916 | resv_entry: RESV
1916		create_resv(block_state.name.buf, block_state.rpass.buf, &block_state.mask.list);
1917		};
1918
1919	<	resv_items:     resv_items resv_item | resv_item;
1920	<	resv_item:      resv_mask | resv_reason | resv_exempt | error ';' ;
1919	>	resv_items:     resv_items resv_item | resv_item;
1920	>	resv_item:      resv_mask | resv_reason | resv_exempt | error ';' ;
1921
1922		resv_mask: MASK '=' QSTRING ';'
1923		{
#	Line 1972 | Line 2087 | cluster_entry: T_CLUSTER
2087		conf->name = xstrdup(block_state.name.buf);
2088		};
2089
2090	<	cluster_items:  cluster_items cluster_item | cluster_item;
2091	<	cluster_item:   cluster_name | cluster_type | error ';' ;
2090	>	cluster_items:  cluster_items cluster_item | cluster_item;
2091	>	cluster_item:   cluster_name | cluster_type | error ';' ;
2092
2093		cluster_name: NAME '=' QSTRING ';'
2094		{
#	Line 1987 | Line 2102 | cluster_type: TYPE
2102		block_state.flags.value = 0;
2103		} '=' cluster_types ';' ;
2104
2105	<	cluster_types:  cluster_types ',' cluster_type_item | cluster_type_item;
2105	>	cluster_types:  cluster_types ',' cluster_type_item | cluster_type_item;
2106		cluster_type_item: KLINE
2107		{
2108		if (conf_parser_ctx.pass == 2)
#	Line 2033 | Line 2148 | cluster_type_item: KLINE
2148		/***************************************************************************
2149		*  section connect
2150		***************************************************************************/
2151	<	connect_entry: CONNECT
2151	>	connect_entry: CONNECT
2152		{
2153
2154		if (conf_parser_ctx.pass != 2)
2155		break;
2156
2157		reset_block_state();
2158	+	block_state.aftype.value = AF_INET;
2159		block_state.port.value = PORTNUM;
2160		} '{' connect_items '}' ';'
2161		{
#	Line 2091 | Line 2207 | connect_entry: CONNECT
2207		ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", block_state.bind.buf);
2208		else
2209		{
2210	<	assert(res != NULL);
2210	>	assert(res);
2211
2212		memcpy(&conf->bind, res->ai_addr, res->ai_addrlen);
2213		conf->bind.ss.ss_family = res->ai_family;
#	Line 2105 | Line 2221 | connect_entry: CONNECT
2221		};
2222
2223		connect_items:  connect_items connect_item | connect_item;
2224	<	connect_item:   connect_name | connect_host | connect_vhost |
2225	<	connect_send_password | connect_accept_password |
2226	<	connect_ssl_certificate_fingerprint |
2227	<	connect_aftype | connect_port | connect_ssl_cipher_list |
2228	<	connect_flags | connect_hub_mask | connect_leaf_mask |
2229	<	connect_class | connect_encrypted |
2224	>	connect_item:   connect_name |
2225	>	connect_host |
2226	>	connect_vhost |
2227	>	connect_send_password |
2228	>	connect_accept_password |
2229	>	connect_ssl_certificate_fingerprint |
2230	>	connect_aftype |
2231	>	connect_port |
2232	>	connect_ssl_cipher_list |
2233	>	connect_flags |
2234	>	connect_hub_mask |
2235	>	connect_leaf_mask |
2236	>	connect_class |
2237	>	connect_encrypted |
2238		error ';' ;
2239
2240		connect_name: NAME '=' QSTRING ';'
#	Line 2119 | Line 2243 | connect_name: NAME '=' QSTRING ';'
2243		strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
2244		};
2245
2246	<	connect_host: HOST '=' QSTRING ';'
2246	>	connect_host: HOST '=' QSTRING ';'
2247		{
2248		if (conf_parser_ctx.pass == 2)
2249		strlcpy(block_state.host.buf, yylval.string, sizeof(block_state.host.buf));
2250		};
2251
2252	<	connect_vhost: VHOST '=' QSTRING ';'
2252	>	connect_vhost: VHOST '=' QSTRING ';'
2253		{
2254		if (conf_parser_ctx.pass == 2)
2255		strlcpy(block_state.bind.buf, yylval.string, sizeof(block_state.bind.buf));
2256		};
2257	<
2257	>
2258		connect_send_password: SEND_PASSWORD '=' QSTRING ';'
2259		{
2260		if (conf_parser_ctx.pass != 2)
#	Line 2138 | Line 2262 | connect_send_password: SEND_PASSWORD '='
2262
2263		if ($3[0] == ':')
2264		conf_error_report("Server passwords cannot begin with a colon");
2265	<	else if (strchr($3, ' ') != NULL)
2265	>	else if (strchr($3, ' '))
2266		conf_error_report("Server passwords cannot contain spaces");
2267		else
2268		strlcpy(block_state.spass.buf, yylval.string, sizeof(block_state.spass.buf));
#	Line 2151 | Line 2275 | connect_accept_password: ACCEPT_PASSWORD
2275
2276		if ($3[0] == ':')
2277		conf_error_report("Server passwords cannot begin with a colon");
2278	<	else if (strchr($3, ' ') != NULL)
2278	>	else if (strchr($3, ' '))
2279		conf_error_report("Server passwords cannot contain spaces");
2280		else
2281		strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
#	Line 2175 | Line 2299 | connect_aftype: AFTYPE '=' T_IPV4 ';'
2299		block_state.aftype.value = AF_INET;
2300		} | AFTYPE '=' T_IPV6 ';'
2301		{
2178	–	#ifdef IPV6
2302		if (conf_parser_ctx.pass == 2)
2303		block_state.aftype.value = AF_INET6;
2181	–	#endif
2304		};
2305
2306		connect_flags: IRCD_FLAGS
#	Line 2208 | Line 2330 | connect_encrypted: ENCRYPTED '=' TBOOL '
2330		}
2331		};
2332
2333	<	connect_hub_mask: HUB_MASK '=' QSTRING ';'
2333	>	connect_hub_mask: HUB_MASK '=' QSTRING ';'
2334		{
2335		if (conf_parser_ctx.pass == 2)
2336		dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.hub.list);
2337		};
2338
2339	<	connect_leaf_mask: LEAF_MASK '=' QSTRING ';'
2339	>	connect_leaf_mask: LEAF_MASK '=' QSTRING ';'
2340		{
2341		if (conf_parser_ctx.pass == 2)
2342		dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.leaf.list);
#	Line 2265 | Line 2387 | kill_entry: KILL
2387		else
2388		conf->reason = xstrdup(CONF_NOREASON);
2389		add_conf_by_address(CONF_KLINE, conf);
2390	<	};
2390	>	};
2391
2392		kill_items:     kill_items kill_item | kill_item;
2393		kill_item:      kill_user | kill_reason | error;
#	Line 2290 | Line 2412 | kill_user: USER '=' QSTRING ';'
2412		}
2413		};
2414
2415	<	kill_reason: REASON '=' QSTRING ';'
2415	>	kill_reason: REASON '=' QSTRING ';'
2416		{
2417		if (conf_parser_ctx.pass == 2)
2418		strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
#	Line 2299 | Line 2421 | kill_reason: REASON '=' QSTRING ';'
2421		/***************************************************************************
2422		*  section deny
2423		***************************************************************************/
2424	<	deny_entry: DENY
2424	>	deny_entry: DENY
2425		{
2426		if (conf_parser_ctx.pass == 2)
2427		reset_block_state();
#	Line 2324 | Line 2446 | deny_entry: DENY
2446		conf->reason = xstrdup(CONF_NOREASON);
2447		add_conf_by_address(CONF_DLINE, conf);
2448		}
2449	<	};
2449	>	};
2450
2451		deny_items:     deny_items deny_item | deny_item;
2452		deny_item:      deny_ip | deny_reason | error;
#	Line 2335 | Line 2457 | deny_ip: IP '=' QSTRING ';'
2457		strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
2458		};
2459
2460	<	deny_reason: REASON '=' QSTRING ';'
2460	>	deny_reason: REASON '=' QSTRING ';'
2461		{
2462		if (conf_parser_ctx.pass == 2)
2463		strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
#	Line 2392 | Line 2514 | gecos_entry: GECOS
2514		gecos_items: gecos_items gecos_item | gecos_item;
2515		gecos_item:  gecos_name | gecos_reason | error;
2516
2517	<	gecos_name: NAME '=' QSTRING ';'
2517	>	gecos_name: NAME '=' QSTRING ';'
2518		{
2519		if (conf_parser_ctx.pass == 2)
2520		strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
2521		};
2522
2523	<	gecos_reason: REASON '=' QSTRING ';'
2523	>	gecos_reason: REASON '=' QSTRING ';'
2524		{
2525		if (conf_parser_ctx.pass == 2)
2526		strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
#	Line 2411 | Line 2533 | general_entry: GENERAL
2533		'{' general_items '}' ';';
2534
2535		general_items:      general_items general_item | general_item;
2536	<	general_item:       general_hide_spoof_ips | general_ignore_bogus_ts |
2537	<	general_failed_oper_notice | general_anti_nick_flood |
2538	<	general_max_nick_time | general_max_nick_changes |
2539	<	general_max_accept | general_anti_spam_exit_message_time |
2540	<	general_ts_warn_delta | general_ts_max_delta |
2536	>	general_item:       general_away_count |
2537	>	general_away_time |
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_nline | general_dots_in_ident |
2550	<	general_stats_o_oper_only | general_stats_k_oper_only |
2551	<	general_pace_wait | general_stats_i_oper_only |
2552	<	general_pace_wait_simple | general_stats_P_oper_only |
2553	<	general_short_motd | general_no_oper_flood |
2554	<	general_true_no_oper_flood | general_oper_pass_resv |
2555	<	general_oper_only_umodes | general_max_targets |
2556	<	general_use_egd | general_egdpool_path |
2557	<	general_oper_umodes | general_caller_id_wait |
2558	<	general_opers_bypass_callerid | general_default_floodcount |
2559	<	general_min_nonwildcard | general_min_nonwildcard_simple |
2560	<	general_throttle_time | general_havent_read_conf |
2549	>	general_warn_no_connect_block |
2550	>	general_dots_in_ident |
2551	>	general_stats_i_oper_only |
2552	>	general_stats_k_oper_only |
2553	>	general_stats_m_oper_only |
2554	>	general_stats_o_oper_only |
2555	>	general_stats_P_oper_only |
2556	>	general_stats_u_oper_only |
2557	>	general_pace_wait |
2558	>	general_pace_wait_simple |
2559	>	general_short_motd |
2560	>	general_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 | general_gline_enable |
2576	<	general_gline_duration | general_gline_request_duration |
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 | general_services_name |
2583	<	error;
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	<	ConfigFileEntry.max_watch = $3;
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	<	ConfigFileEntry.glines = yylval.number;
2611	>	ConfigGeneral.glines = yylval.number;
2612		};
2613
2614		general_gline_duration: GLINE_DURATION '=' timespec ';'
2615		{
2616		if (conf_parser_ctx.pass == 2)
2617	<	ConfigFileEntry.gline_time = $3;
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	<	ConfigFileEntry.gline_request_time = $3;
2623	>	ConfigGeneral.gline_request_time = $3;
2624		};
2625
2626		general_gline_min_cidr: GLINE_MIN_CIDR '=' NUMBER ';'
2627		{
2628	<	ConfigFileEntry.gline_min_cidr = $3;
2628	>	ConfigGeneral.gline_min_cidr = $3;
2629		};
2630
2631		general_gline_min_cidr6: GLINE_MIN_CIDR6 '=' NUMBER ';'
2632		{
2633	<	ConfigFileEntry.gline_min_cidr6 = $3;
2633	>	ConfigGeneral.gline_min_cidr6 = $3;
2634		};
2635
2636		general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
2637		{
2638	<	ConfigFileEntry.tkline_expire_notices = yylval.number;
2638	>	ConfigGeneral.tkline_expire_notices = yylval.number;
2639		};
2640
2641		general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' timespec ';'
2642		{
2643	<	ConfigFileEntry.kill_chase_time_limit = $3;
2485	<	};
2486	<
2487	<	general_hide_spoof_ips: HIDE_SPOOF_IPS '=' TBOOL ';'
2488	<	{
2489	<	ConfigFileEntry.hide_spoof_ips = yylval.number;
2643	>	ConfigGeneral.kill_chase_time_limit = $3;
2644		};
2645
2646		general_ignore_bogus_ts: IGNORE_BOGUS_TS '=' TBOOL ';'
2647		{
2648	<	ConfigFileEntry.ignore_bogus_ts = yylval.number;
2648	>	ConfigGeneral.ignore_bogus_ts = yylval.number;
2649		};
2650
2651		general_failed_oper_notice: FAILED_OPER_NOTICE '=' TBOOL ';'
2652		{
2653	<	ConfigFileEntry.failed_oper_notice = yylval.number;
2653	>	ConfigGeneral.failed_oper_notice = yylval.number;
2654		};
2655
2656		general_anti_nick_flood: ANTI_NICK_FLOOD '=' TBOOL ';'
2657		{
2658	<	ConfigFileEntry.anti_nick_flood = yylval.number;
2658	>	ConfigGeneral.anti_nick_flood = yylval.number;
2659		};
2660
2661		general_max_nick_time: MAX_NICK_TIME '=' timespec ';'
2662		{
2663	<	ConfigFileEntry.max_nick_time = $3;
2663	>	ConfigGeneral.max_nick_time = $3;
2664		};
2665
2666		general_max_nick_changes: MAX_NICK_CHANGES '=' NUMBER ';'
2667		{
2668	<	ConfigFileEntry.max_nick_changes = $3;
2668	>	ConfigGeneral.max_nick_changes = $3;
2669		};
2670
2671		general_max_accept: MAX_ACCEPT '=' NUMBER ';'
2672		{
2673	<	ConfigFileEntry.max_accept = $3;
2673	>	ConfigGeneral.max_accept = $3;
2674		};
2675
2676		general_anti_spam_exit_message_time: ANTI_SPAM_EXIT_MESSAGE_TIME '=' timespec ';'
2677		{
2678	<	ConfigFileEntry.anti_spam_exit_message_time = $3;
2678	>	ConfigGeneral.anti_spam_exit_message_time = $3;
2679		};
2680
2681		general_ts_warn_delta: TS_WARN_DELTA '=' timespec ';'
2682		{
2683	<	ConfigFileEntry.ts_warn_delta = $3;
2683	>	ConfigGeneral.ts_warn_delta = $3;
2684		};
2685
2686		general_ts_max_delta: TS_MAX_DELTA '=' timespec ';'
2687		{
2688		if (conf_parser_ctx.pass == 2)
2689	<	ConfigFileEntry.ts_max_delta = $3;
2689	>	ConfigGeneral.ts_max_delta = $3;
2690		};
2691
2692		general_havent_read_conf: HAVENT_READ_CONF '=' NUMBER ';'
#	Line 2548 | Line 2702 | general_havent_read_conf: HAVENT_READ_CO
2702
2703		general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
2704		{
2705	<	ConfigFileEntry.invisible_on_connect = yylval.number;
2705	>	ConfigGeneral.invisible_on_connect = yylval.number;
2706		};
2707
2708	<	general_warn_no_nline: WARN_NO_NLINE '=' TBOOL ';'
2708	>	general_warn_no_connect_block: WARN_NO_CONNECT_BLOCK '=' TBOOL ';'
2709		{
2710	<	ConfigFileEntry.warn_no_nline = yylval.number;
2710	>	ConfigGeneral.warn_no_connect_block = yylval.number;
2711		};
2712
2713		general_stats_e_disabled: STATS_E_DISABLED '=' TBOOL ';'
2714		{
2715	<	ConfigFileEntry.stats_e_disabled = yylval.number;
2715	>	ConfigGeneral.stats_e_disabled = yylval.number;
2716	>	};
2717	>
2718	>	general_stats_m_oper_only: STATS_M_OPER_ONLY '=' TBOOL ';'
2719	>	{
2720	>	ConfigGeneral.stats_m_oper_only = yylval.number;
2721		};
2722
2723		general_stats_o_oper_only: STATS_O_OPER_ONLY '=' TBOOL ';'
2724		{
2725	<	ConfigFileEntry.stats_o_oper_only = yylval.number;
2725	>	ConfigGeneral.stats_o_oper_only = yylval.number;
2726		};
2727
2728		general_stats_P_oper_only: STATS_P_OPER_ONLY '=' TBOOL ';'
2729		{
2730	<	ConfigFileEntry.stats_P_oper_only = yylval.number;
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	<	ConfigFileEntry.stats_k_oper_only = 2 * yylval.number;
2740	>	ConfigGeneral.stats_k_oper_only = 2 * yylval.number;
2741		} | STATS_K_OPER_ONLY '=' TMASKED ';'
2742		{
2743	<	ConfigFileEntry.stats_k_oper_only = 1;
2743	>	ConfigGeneral.stats_k_oper_only = 1;
2744		};
2745
2746		general_stats_i_oper_only: STATS_I_OPER_ONLY '=' TBOOL ';'
2747		{
2748	<	ConfigFileEntry.stats_i_oper_only = 2 * yylval.number;
2748	>	ConfigGeneral.stats_i_oper_only = 2 * yylval.number;
2749		} | STATS_I_OPER_ONLY '=' TMASKED ';'
2750		{
2751	<	ConfigFileEntry.stats_i_oper_only = 1;
2751	>	ConfigGeneral.stats_i_oper_only = 1;
2752		};
2753
2754		general_pace_wait: PACE_WAIT '=' timespec ';'
2755		{
2756	<	ConfigFileEntry.pace_wait = $3;
2756	>	ConfigGeneral.pace_wait = $3;
2757		};
2758
2759		general_caller_id_wait: CALLER_ID_WAIT '=' timespec ';'
2760		{
2761	<	ConfigFileEntry.caller_id_wait = $3;
2761	>	ConfigGeneral.caller_id_wait = $3;
2762		};
2763
2764		general_opers_bypass_callerid: OPERS_BYPASS_CALLERID '=' TBOOL ';'
2765		{
2766	<	ConfigFileEntry.opers_bypass_callerid = yylval.number;
2766	>	ConfigGeneral.opers_bypass_callerid = yylval.number;
2767		};
2768
2769		general_pace_wait_simple: PACE_WAIT_SIMPLE '=' timespec ';'
2770		{
2771	<	ConfigFileEntry.pace_wait_simple = $3;
2771	>	ConfigGeneral.pace_wait_simple = $3;
2772		};
2773
2774		general_short_motd: SHORT_MOTD '=' TBOOL ';'
2775		{
2776	<	ConfigFileEntry.short_motd = yylval.number;
2613	<	};
2614	<
2615	<	general_no_oper_flood: NO_OPER_FLOOD '=' TBOOL ';'
2616	<	{
2617	<	ConfigFileEntry.no_oper_flood = yylval.number;
2776	>	ConfigGeneral.short_motd = yylval.number;
2777		};
2778
2779	<	general_true_no_oper_flood: TRUE_NO_OPER_FLOOD '=' TBOOL ';'
2779	>	general_no_oper_flood: NO_OPER_FLOOD '=' TBOOL ';'
2780		{
2781	<	ConfigFileEntry.true_no_oper_flood = yylval.number;
2781	>	ConfigGeneral.no_oper_flood = yylval.number;
2782		};
2783
2784		general_oper_pass_resv: OPER_PASS_RESV '=' TBOOL ';'
2785		{
2786	<	ConfigFileEntry.oper_pass_resv = yylval.number;
2786	>	ConfigGeneral.oper_pass_resv = yylval.number;
2787		};
2788
2789		general_dots_in_ident: DOTS_IN_IDENT '=' NUMBER ';'
2790		{
2791	<	ConfigFileEntry.dots_in_ident = $3;
2791	>	ConfigGeneral.dots_in_ident = $3;
2792		};
2793
2794		general_max_targets: MAX_TARGETS '=' NUMBER ';'
2795		{
2796	<	ConfigFileEntry.max_targets = $3;
2796	>	ConfigGeneral.max_targets = $3;
2797		};
2798
2799	<	general_use_egd: USE_EGD '=' TBOOL ';'
2641	<	{
2642	<	ConfigFileEntry.use_egd = yylval.number;
2643	<	};
2644	<
2645	<	general_egdpool_path: EGDPOOL_PATH '=' QSTRING ';'
2646	<	{
2647	<	if (conf_parser_ctx.pass == 2)
2648	<	{
2649	<	MyFree(ConfigFileEntry.egdpool_path);
2650	<	ConfigFileEntry.egdpool_path = xstrdup(yylval.string);
2651	<	}
2652	<	};
2653	<
2654	<	general_services_name: T_SERVICES_NAME '=' QSTRING ';'
2799	>	general_ping_cookie: PING_COOKIE '=' TBOOL ';'
2800		{
2801	<	if (conf_parser_ctx.pass == 2 && valid_servname(yylval.string))
2657	<	{
2658	<	MyFree(ConfigFileEntry.service_name);
2659	<	ConfigFileEntry.service_name = xstrdup(yylval.string);
2660	<	}
2801	>	ConfigGeneral.ping_cookie = yylval.number;
2802		};
2803
2804	<	general_ping_cookie: PING_COOKIE '=' TBOOL ';'
2804	>	general_disable_auth: DISABLE_AUTH '=' TBOOL ';'
2805		{
2806	<	ConfigFileEntry.ping_cookie = yylval.number;
2806	>	ConfigGeneral.disable_auth = yylval.number;
2807		};
2808
2809	<	general_disable_auth: DISABLE_AUTH '=' TBOOL ';'
2809	>	general_throttle_count: THROTTLE_COUNT '=' NUMBER ';'
2810		{
2811	<	ConfigFileEntry.disable_auth = yylval.number;
2811	>	ConfigGeneral.throttle_count = $3;
2812		};
2813
2814		general_throttle_time: THROTTLE_TIME '=' timespec ';'
2815		{
2816	<	ConfigFileEntry.throttle_time = yylval.number;
2816	>	ConfigGeneral.throttle_time = $3;
2817		};
2818
2819		general_oper_umodes: OPER_UMODES
2820		{
2821	<	ConfigFileEntry.oper_umodes = 0;
2821	>	ConfigGeneral.oper_umodes = 0;
2822		} '='  umode_oitems ';' ;
2823
2824		umode_oitems:    umode_oitems ',' umode_oitem | umode_oitem;
2825		umode_oitem:     T_BOTS
2826		{
2827	<	ConfigFileEntry.oper_umodes |= UMODE_BOTS;
2827	>	ConfigGeneral.oper_umodes |= UMODE_BOTS;
2828		} | T_CCONN
2829		{
2830	<	ConfigFileEntry.oper_umodes |= UMODE_CCONN;
2830	>	ConfigGeneral.oper_umodes |= UMODE_CCONN;
2831		} | T_DEAF
2832		{
2833	<	ConfigFileEntry.oper_umodes |= UMODE_DEAF;
2833	>	ConfigGeneral.oper_umodes |= UMODE_DEAF;
2834		} | T_DEBUG
2835		{
2836	<	ConfigFileEntry.oper_umodes |= UMODE_DEBUG;
2836	>	ConfigGeneral.oper_umodes |= UMODE_DEBUG;
2837		} | T_FULL
2838		{
2839	<	ConfigFileEntry.oper_umodes |= UMODE_FULL;
2839	>	ConfigGeneral.oper_umodes |= UMODE_FULL;
2840		} | HIDDEN
2841		{
2842	<	ConfigFileEntry.oper_umodes |= UMODE_HIDDEN;
2842	>	ConfigGeneral.oper_umodes |= UMODE_HIDDEN;
2843	>	} | HIDE_CHANS
2844	>	{
2845	>	ConfigGeneral.oper_umodes |= UMODE_HIDECHANS;
2846	>	} | HIDE_IDLE
2847	>	{
2848	>	ConfigGeneral.oper_umodes |= UMODE_HIDEIDLE;
2849		} | T_SKILL
2850		{
2851	<	ConfigFileEntry.oper_umodes |= UMODE_SKILL;
2851	>	ConfigGeneral.oper_umodes |= UMODE_SKILL;
2852		} | T_NCHANGE
2853		{
2854	<	ConfigFileEntry.oper_umodes |= UMODE_NCHANGE;
2854	>	ConfigGeneral.oper_umodes |= UMODE_NCHANGE;
2855		} | T_REJ
2856		{
2857	<	ConfigFileEntry.oper_umodes |= UMODE_REJ;
2857	>	ConfigGeneral.oper_umodes |= UMODE_REJ;
2858		} | T_UNAUTH
2859		{
2860	<	ConfigFileEntry.oper_umodes |= UMODE_UNAUTH;
2860	>	ConfigGeneral.oper_umodes |= UMODE_UNAUTH;
2861		} | T_SPY
2862		{
2863	<	ConfigFileEntry.oper_umodes |= UMODE_SPY;
2863	>	ConfigGeneral.oper_umodes |= UMODE_SPY;
2864		} | T_EXTERNAL
2865		{
2866	<	ConfigFileEntry.oper_umodes |= UMODE_EXTERNAL;
2720	<	} | T_OPERWALL
2721	<	{
2722	<	ConfigFileEntry.oper_umodes |= UMODE_OPERWALL;
2866	>	ConfigGeneral.oper_umodes |= UMODE_EXTERNAL;
2867		} | T_SERVNOTICE
2868		{
2869	<	ConfigFileEntry.oper_umodes |= UMODE_SERVNOTICE;
2869	>	ConfigGeneral.oper_umodes |= UMODE_SERVNOTICE;
2870		} | T_INVISIBLE
2871		{
2872	<	ConfigFileEntry.oper_umodes |= UMODE_INVISIBLE;
2872	>	ConfigGeneral.oper_umodes |= UMODE_INVISIBLE;
2873		} | T_WALLOP
2874		{
2875	<	ConfigFileEntry.oper_umodes |= UMODE_WALLOP;
2875	>	ConfigGeneral.oper_umodes |= UMODE_WALLOP;
2876		} | T_SOFTCALLERID
2877		{
2878	<	ConfigFileEntry.oper_umodes |= UMODE_SOFTCALLERID;
2878	>	ConfigGeneral.oper_umodes |= UMODE_SOFTCALLERID;
2879		} | T_CALLERID
2880		{
2881	<	ConfigFileEntry.oper_umodes |= UMODE_CALLERID;
2881	>	ConfigGeneral.oper_umodes |= UMODE_CALLERID;
2882		} | T_LOCOPS
2883		{
2884	<	ConfigFileEntry.oper_umodes |= UMODE_LOCOPS;
2884	>	ConfigGeneral.oper_umodes |= UMODE_LOCOPS;
2885		} | T_NONONREG
2886		{
2887	<	ConfigFileEntry.oper_umodes |= UMODE_REGONLY;
2887	>	ConfigGeneral.oper_umodes |= UMODE_REGONLY;
2888		} | T_FARCONNECT
2889		{
2890	<	ConfigFileEntry.oper_umodes |= UMODE_FARCONNECT;
2890	>	ConfigGeneral.oper_umodes |= UMODE_FARCONNECT;
2891		};
2892
2893	<	general_oper_only_umodes: OPER_ONLY_UMODES
2893	>	general_oper_only_umodes: OPER_ONLY_UMODES
2894		{
2895	<	ConfigFileEntry.oper_only_umodes = 0;
2895	>	ConfigGeneral.oper_only_umodes = 0;
2896		} '='  umode_items ';' ;
2897
2898	<	umode_items:    umode_items ',' umode_item | umode_item;
2899	<	umode_item:     T_BOTS
2898	>	umode_items:  umode_items ',' umode_item | umode_item;
2899	>	umode_item:   T_BOTS
2900		{
2901	<	ConfigFileEntry.oper_only_umodes |= UMODE_BOTS;
2901	>	ConfigGeneral.oper_only_umodes |= UMODE_BOTS;
2902		} | T_CCONN
2903		{
2904	<	ConfigFileEntry.oper_only_umodes |= UMODE_CCONN;
2904	>	ConfigGeneral.oper_only_umodes |= UMODE_CCONN;
2905		} | T_DEAF
2906		{
2907	<	ConfigFileEntry.oper_only_umodes |= UMODE_DEAF;
2907	>	ConfigGeneral.oper_only_umodes |= UMODE_DEAF;
2908		} | T_DEBUG
2909		{
2910	<	ConfigFileEntry.oper_only_umodes |= UMODE_DEBUG;
2910	>	ConfigGeneral.oper_only_umodes |= UMODE_DEBUG;
2911		} | T_FULL
2912	<	{
2913	<	ConfigFileEntry.oper_only_umodes |= UMODE_FULL;
2912	>	{
2913	>	ConfigGeneral.oper_only_umodes |= UMODE_FULL;
2914		} | T_SKILL
2915		{
2916	<	ConfigFileEntry.oper_only_umodes |= UMODE_SKILL;
2916	>	ConfigGeneral.oper_only_umodes |= UMODE_SKILL;
2917		} | HIDDEN
2918		{
2919	<	ConfigFileEntry.oper_only_umodes |= UMODE_HIDDEN;
2919	>	ConfigGeneral.oper_only_umodes |= UMODE_HIDDEN;
2920		} | T_NCHANGE
2921		{
2922	<	ConfigFileEntry.oper_only_umodes |= UMODE_NCHANGE;
2922	>	ConfigGeneral.oper_only_umodes |= UMODE_NCHANGE;
2923		} | T_REJ
2924		{
2925	<	ConfigFileEntry.oper_only_umodes |= UMODE_REJ;
2925	>	ConfigGeneral.oper_only_umodes |= UMODE_REJ;
2926		} | T_UNAUTH
2927		{
2928	<	ConfigFileEntry.oper_only_umodes |= UMODE_UNAUTH;
2928	>	ConfigGeneral.oper_only_umodes |= UMODE_UNAUTH;
2929		} | T_SPY
2930		{
2931	<	ConfigFileEntry.oper_only_umodes |= UMODE_SPY;
2931	>	ConfigGeneral.oper_only_umodes |= UMODE_SPY;
2932		} | T_EXTERNAL
2933		{
2934	<	ConfigFileEntry.oper_only_umodes |= UMODE_EXTERNAL;
2791	<	} | T_OPERWALL
2792	<	{
2793	<	ConfigFileEntry.oper_only_umodes |= UMODE_OPERWALL;
2934	>	ConfigGeneral.oper_only_umodes |= UMODE_EXTERNAL;
2935		} | T_SERVNOTICE
2936		{
2937	<	ConfigFileEntry.oper_only_umodes |= UMODE_SERVNOTICE;
2937	>	ConfigGeneral.oper_only_umodes |= UMODE_SERVNOTICE;
2938		} | T_INVISIBLE
2939		{
2940	<	ConfigFileEntry.oper_only_umodes |= UMODE_INVISIBLE;
2940	>	ConfigGeneral.oper_only_umodes |= UMODE_INVISIBLE;
2941		} | T_WALLOP
2942		{
2943	<	ConfigFileEntry.oper_only_umodes |= UMODE_WALLOP;
2943	>	ConfigGeneral.oper_only_umodes |= UMODE_WALLOP;
2944		} | T_SOFTCALLERID
2945		{
2946	<	ConfigFileEntry.oper_only_umodes |= UMODE_SOFTCALLERID;
2946	>	ConfigGeneral.oper_only_umodes |= UMODE_SOFTCALLERID;
2947		} | T_CALLERID
2948		{
2949	<	ConfigFileEntry.oper_only_umodes |= UMODE_CALLERID;
2949	>	ConfigGeneral.oper_only_umodes |= UMODE_CALLERID;
2950		} | T_LOCOPS
2951		{
2952	<	ConfigFileEntry.oper_only_umodes |= UMODE_LOCOPS;
2952	>	ConfigGeneral.oper_only_umodes |= UMODE_LOCOPS;
2953		} | T_NONONREG
2954		{
2955	<	ConfigFileEntry.oper_only_umodes |= UMODE_REGONLY;
2955	>	ConfigGeneral.oper_only_umodes |= UMODE_REGONLY;
2956		} | T_FARCONNECT
2957		{
2958	<	ConfigFileEntry.oper_only_umodes |= UMODE_FARCONNECT;
2958	>	ConfigGeneral.oper_only_umodes |= UMODE_FARCONNECT;
2959		};
2960
2961		general_min_nonwildcard: MIN_NONWILDCARD '=' NUMBER ';'
2962		{
2963	<	ConfigFileEntry.min_nonwildcard = $3;
2963	>	ConfigGeneral.min_nonwildcard = $3;
2964		};
2965
2966		general_min_nonwildcard_simple: MIN_NONWILDCARD_SIMPLE '=' NUMBER ';'
2967		{
2968	<	ConfigFileEntry.min_nonwildcard_simple = $3;
2968	>	ConfigGeneral.min_nonwildcard_simple = $3;
2969		};
2970
2971		general_default_floodcount: DEFAULT_FLOODCOUNT '=' NUMBER ';'
2972		{
2973	<	ConfigFileEntry.default_floodcount = $3;
2973	>	ConfigGeneral.default_floodcount = $3;
2974		};
2975
2976
#	Line 2841 | Line 2982 | channel_entry: CHANNEL
2982
2983		channel_items:      channel_items channel_item | channel_item;
2984		channel_item:       channel_max_bans |
2985	<	channel_knock_delay | channel_knock_delay_channel |
2986	<	channel_max_chans_per_user | channel_max_chans_per_oper |
2985	>	channel_invite_client_count |
2986	>	channel_invite_client_time |
2987	>	channel_knock_client_count |
2988	>	channel_knock_client_time |
2989	>	channel_knock_delay_channel |
2990	>	channel_max_channels |
2991		channel_default_split_user_count |
2992		channel_default_split_server_count |
2993		channel_no_create_on_split |
2994		channel_no_join_on_split |
2995	<	channel_jflood_count | channel_jflood_time |
2996	<	channel_disable_fake_channels | error;
2995	>	channel_jflood_count |
2996	>	channel_jflood_time |
2997	>	channel_disable_fake_channels |
2998	>	error;
2999
3000		channel_disable_fake_channels: DISABLE_FAKE_CHANNELS '=' TBOOL ';'
3001		{
3002		ConfigChannel.disable_fake_channels = yylval.number;
3003		};
3004
3005	<	channel_knock_delay: KNOCK_DELAY '=' timespec ';'
3005	>	channel_invite_client_count: INVITE_CLIENT_COUNT '=' NUMBER ';'
3006		{
3007	<	ConfigChannel.knock_delay = $3;
3007	>	ConfigChannel.invite_client_count = $3;
3008		};
3009
3010	<	channel_knock_delay_channel: KNOCK_DELAY_CHANNEL '=' timespec ';'
3010	>	channel_invite_client_time: INVITE_CLIENT_TIME '=' timespec ';'
3011		{
3012	<	ConfigChannel.knock_delay_channel = $3;
3012	>	ConfigChannel.invite_client_time = $3;
3013	>	};
3014	>
3015	>	channel_knock_client_count: KNOCK_CLIENT_COUNT '=' NUMBER ';'
3016	>	{
3017	>	ConfigChannel.knock_client_count = $3;
3018	>	};
3019	>
3020	>	channel_knock_client_time: KNOCK_CLIENT_TIME '=' timespec ';'
3021	>	{
3022	>	ConfigChannel.knock_client_time = $3;
3023		};
3024
3025	<	channel_max_chans_per_user: MAX_CHANS_PER_USER '=' NUMBER ';'
3025	>	channel_knock_delay_channel: KNOCK_DELAY_CHANNEL '=' timespec ';'
3026		{
3027	<	ConfigChannel.max_chans_per_user = $3;
3027	>	ConfigChannel.knock_delay_channel = $3;
3028		};
3029
3030	<	channel_max_chans_per_oper: MAX_CHANS_PER_OPER '=' NUMBER ';'
3030	>	channel_max_channels: MAX_CHANNELS '=' NUMBER ';'
3031		{
3032	<	ConfigChannel.max_chans_per_oper = $3;
3032	>	ConfigChannel.max_channels = $3;
3033		};
3034
3035		channel_max_bans: MAX_BANS '=' NUMBER ';'
#	Line 2907 | Line 3064 | channel_jflood_count: JOIN_FLOOD_COUNT '
3064
3065		channel_jflood_time: JOIN_FLOOD_TIME '=' timespec ';'
3066		{
3067	<	GlobalSetOptions.joinfloodtime = yylval.number;
3067	>	GlobalSetOptions.joinfloodtime = $3;
3068		};
3069
3070		/***************************************************************************
#	Line 2917 | Line 3074 | serverhide_entry: SERVERHIDE
3074		'{' serverhide_items '}' ';';
3075
3076		serverhide_items:   serverhide_items serverhide_item | serverhide_item;
3077	<	serverhide_item:    serverhide_flatten_links | serverhide_disable_remote_commands |
3077	>	serverhide_item:    serverhide_flatten_links |
3078	>	serverhide_disable_remote_commands |
3079		serverhide_hide_servers |
3080	<	serverhide_hide_services |
3081	<	serverhide_links_delay |
3082	<	serverhide_hidden | serverhide_hidden_name |
3083	<	serverhide_hide_server_ips |
3080	>	serverhide_hide_services |
3081	>	serverhide_links_delay |
3082	>	serverhide_hidden |
3083	>	serverhide_hidden_name |
3084	>	serverhide_hide_server_ips |
3085		error;
3086
3087		serverhide_flatten_links: FLATTEN_LINKS '=' TBOOL ';'
#	Line 2964 | Line 3123 | serverhide_links_delay: LINKS_DELAY '='
3123		{
3124		if (($3 > 0) && ConfigServerHide.links_disabled == 1)
3125		{
3126	<	eventAddIsh("write_links_file", write_links_file, NULL, $3);
3126	>	event_write_links_file.when = $3;
3127	>	event_addish(&event_write_links_file, NULL);
3128		ConfigServerHide.links_disabled = 0;
3129		}
3130

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)