ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 1823
Committed: Sun Apr 14 18:24:38 2013 UTC (12 years, 4 months ago) by michael
File size: 74653 byte(s)
Log Message: 
- Renamed example.conf to reference.conf
- Due to upcoming feature implementation, resv{} blocks are no longer stackable

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

Properties

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