ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 1855
Committed: Wed Apr 24 19:26:23 2013 UTC (13 years, 3 months ago) by michael
File size: 74736 byte(s)
Log Message: 
- Added 'nononreg' (+R) to oper::umodes and general::oper_only_modes

File Contents

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

Properties

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