ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-8/src/conf_parser.y
Revision: 1352
Committed: Fri Apr 13 09:57:08 2012 UTC (11 years, 11 months ago) by michael
File size: 81761 byte(s)
Log Message:
- conf_parser.y: dh prime size should be at least 1024 bits

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 adx 30 #include "event.h"
37 michael 1309 #include "log.h"
38 adx 30 #include "client.h" /* for UMODE_ALL only */
39     #include "irc_string.h"
40     #include "sprintf_irc.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 1329 int yylex(void);
59    
60 adx 30 static char *class_name = NULL;
61     static struct ConfItem *yy_conf = NULL;
62     static struct AccessItem *yy_aconf = NULL;
63     static struct MatchItem *yy_match_item = NULL;
64     static struct ClassItem *yy_class = NULL;
65     static char *yy_class_name = NULL;
66    
67     static dlink_list col_conf_list = { NULL, NULL, 0 };
68     static dlink_list hub_conf_list = { NULL, NULL, 0 };
69     static dlink_list leaf_conf_list = { NULL, NULL, 0 };
70     static unsigned int listener_flags = 0;
71     static unsigned int regex_ban = 0;
72     static char userbuf[IRCD_BUFSIZE];
73     static char hostbuf[IRCD_BUFSIZE];
74     static char reasonbuf[REASONLEN + 1];
75     static char gecos_name[REALLEN * 4];
76 michael 1247 static char lfile[IRCD_BUFSIZE];
77     static unsigned int ltype = 0;
78     static unsigned int lsize = 0;
79 adx 30 static char *resv_reason = NULL;
80     static char *listener_address = NULL;
81    
82 michael 593 struct CollectItem
83     {
84 adx 30 dlink_node node;
85     char *name;
86     char *user;
87     char *host;
88     char *passwd;
89     int port;
90     int flags;
91     #ifdef HAVE_LIBCRYPTO
92     char *rsa_public_key_file;
93     RSA *rsa_public_key;
94     #endif
95     };
96    
97     static void
98     free_collect_item(struct CollectItem *item)
99     {
100     MyFree(item->name);
101     MyFree(item->user);
102     MyFree(item->host);
103     MyFree(item->passwd);
104     #ifdef HAVE_LIBCRYPTO
105     MyFree(item->rsa_public_key_file);
106     #endif
107     MyFree(item);
108     }
109    
110     static void
111     unhook_hub_leaf_confs(void)
112     {
113     dlink_node *ptr;
114     dlink_node *next_ptr;
115     struct CollectItem *yy_hconf;
116     struct CollectItem *yy_lconf;
117    
118     DLINK_FOREACH_SAFE(ptr, next_ptr, hub_conf_list.head)
119     {
120     yy_hconf = ptr->data;
121     dlinkDelete(&yy_hconf->node, &hub_conf_list);
122     free_collect_item(yy_hconf);
123     }
124    
125     DLINK_FOREACH_SAFE(ptr, next_ptr, leaf_conf_list.head)
126     {
127     yy_lconf = ptr->data;
128     dlinkDelete(&yy_lconf->node, &leaf_conf_list);
129     free_collect_item(yy_lconf);
130     }
131     }
132    
133     %}
134    
135     %union {
136     int number;
137     char *string;
138     }
139    
140     %token ACCEPT_PASSWORD
141     %token ACTION
142     %token ADMIN
143     %token AFTYPE
144     %token T_ALLOW
145     %token ANTI_NICK_FLOOD
146     %token ANTI_SPAM_EXIT_MESSAGE_TIME
147     %token AUTOCONN
148     %token T_BLOCK
149     %token BURST_AWAY
150     %token BURST_TOPICWHO
151     %token BYTES KBYTES MBYTES GBYTES TBYTES
152     %token CALLER_ID_WAIT
153     %token CAN_FLOOD
154     %token CHANNEL
155     %token CIDR_BITLEN_IPV4
156     %token CIDR_BITLEN_IPV6
157     %token CLASS
158     %token CONNECT
159     %token CONNECTFREQ
160     %token DEFAULT_FLOODCOUNT
161     %token DEFAULT_SPLIT_SERVER_COUNT
162     %token DEFAULT_SPLIT_USER_COUNT
163     %token DENY
164     %token DESCRIPTION
165     %token DIE
166     %token DISABLE_AUTH
167 michael 632 %token DISABLE_FAKE_CHANNELS
168 adx 30 %token DISABLE_HIDDEN
169     %token DISABLE_LOCAL_CHANNELS
170     %token DISABLE_REMOTE_COMMANDS
171     %token DOTS_IN_IDENT
172     %token DURATION
173     %token EGDPOOL_PATH
174     %token EMAIL
175     %token ENABLE
176     %token ENCRYPTED
177     %token EXCEED_LIMIT
178     %token EXEMPT
179     %token FAILED_OPER_NOTICE
180     %token IRCD_FLAGS
181     %token FLATTEN_LINKS
182     %token GECOS
183     %token GENERAL
184     %token GLINE
185     %token GLINES
186     %token GLINE_EXEMPT
187     %token GLINE_TIME
188     %token GLINE_MIN_CIDR
189     %token GLINE_MIN_CIDR6
190     %token GLOBAL_KILL
191     %token IRCD_AUTH
192     %token NEED_IDENT
193     %token HAVENT_READ_CONF
194     %token HIDDEN
195     %token HIDDEN_NAME
196     %token HIDE_SERVER_IPS
197     %token HIDE_SERVERS
198     %token HIDE_SPOOF_IPS
199     %token HOST
200     %token HUB
201     %token HUB_MASK
202     %token IGNORE_BOGUS_TS
203     %token INVISIBLE_ON_CONNECT
204     %token IP
205     %token KILL
206     %token KILL_CHASE_TIME_LIMIT
207     %token KLINE
208     %token KLINE_EXEMPT
209     %token KLINE_REASON
210     %token KLINE_WITH_REASON
211     %token KNOCK_DELAY
212     %token KNOCK_DELAY_CHANNEL
213     %token LEAF_MASK
214     %token LINKS_DELAY
215     %token LISTEN
216     %token T_LOG
217     %token MAX_ACCEPT
218     %token MAX_BANS
219     %token MAX_CHANS_PER_USER
220     %token MAX_GLOBAL
221     %token MAX_IDENT
222     %token MAX_LOCAL
223     %token MAX_NICK_CHANGES
224     %token MAX_NICK_TIME
225     %token MAX_NUMBER
226     %token MAX_TARGETS
227 michael 876 %token MAX_WATCH
228 adx 30 %token MESSAGE_LOCALE
229     %token MIN_NONWILDCARD
230     %token MIN_NONWILDCARD_SIMPLE
231     %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_IDENT
245     %token NUMBER_PER_CIDR
246     %token NUMBER_PER_IP
247     %token NUMBER_PER_IP_GLOBAL
248     %token OPERATOR
249     %token OPERS_BYPASS_CALLERID
250     %token OPER_ONLY_UMODES
251     %token OPER_PASS_RESV
252     %token OPER_SPY_T
253     %token OPER_UMODES
254     %token JOIN_FLOOD_COUNT
255     %token JOIN_FLOOD_TIME
256     %token PACE_WAIT
257     %token PACE_WAIT_SIMPLE
258     %token PASSWORD
259     %token PATH
260     %token PING_COOKIE
261     %token PING_TIME
262     %token PING_WARNING
263     %token PORT
264     %token QSTRING
265     %token QUIET_ON_BAN
266     %token REASON
267     %token REDIRPORT
268     %token REDIRSERV
269     %token REGEX_T
270     %token REHASH
271     %token TREJECT_HOLD_TIME
272     %token REMOTE
273     %token REMOTEBAN
274     %token RESTRICT_CHANNELS
275     %token RESTRICTED
276     %token RSA_PRIVATE_KEY_FILE
277     %token RSA_PUBLIC_KEY_FILE
278     %token SSL_CERTIFICATE_FILE
279 michael 1306 %token SSL_DH_PARAM_FILE
280 michael 1316 %token T_SSL_CLIENT_METHOD
281     %token T_SSL_SERVER_METHOD
282 michael 967 %token T_SSLV3
283     %token T_TLSV1
284 adx 30 %token RESV
285     %token RESV_EXEMPT
286     %token SECONDS MINUTES HOURS DAYS WEEKS
287     %token SENDQ
288     %token SEND_PASSWORD
289     %token SERVERHIDE
290     %token SERVERINFO
291     %token IRCD_SID
292     %token TKLINE_EXPIRE_NOTICES
293     %token T_SHARED
294     %token T_CLUSTER
295     %token TYPE
296     %token SHORT_MOTD
297     %token SILENT
298     %token SPOOF
299     %token SPOOF_NOTICE
300 michael 584 %token STATS_E_DISABLED
301 adx 30 %token STATS_I_OPER_ONLY
302     %token STATS_K_OPER_ONLY
303     %token STATS_O_OPER_ONLY
304     %token STATS_P_OPER_ONLY
305     %token TBOOL
306     %token TMASKED
307     %token T_REJECT
308     %token TS_MAX_DELTA
309     %token TS_WARN_DELTA
310     %token TWODOTS
311     %token T_ALL
312     %token T_BOTS
313     %token T_SOFTCALLERID
314     %token T_CALLERID
315     %token T_CCONN
316 db 849 %token T_CCONN_FULL
317 michael 1306 %token T_SSL_CIPHER_LIST
318 adx 30 %token T_CLIENT_FLOOD
319     %token T_DEAF
320     %token T_DEBUG
321 michael 1247 %token T_DLINE
322 adx 30 %token T_DRONE
323     %token T_EXTERNAL
324     %token T_FULL
325     %token T_INVISIBLE
326     %token T_IPV4
327     %token T_IPV6
328     %token T_LOCOPS
329     %token T_MAX_CLIENTS
330     %token T_NCHANGE
331     %token T_OPERWALL
332     %token T_REJ
333 michael 900 %token T_SERVER
334 adx 30 %token T_SERVNOTICE
335     %token T_SKILL
336     %token T_SPY
337     %token T_SSL
338 michael 56 %token T_UMODES
339 adx 30 %token T_UNAUTH
340 michael 1301 %token T_UNDLINE
341 michael 1250 %token T_UNLIMITED
342 adx 30 %token T_UNRESV
343     %token T_UNXLINE
344 michael 1216 %token T_GLOBOPS
345 adx 30 %token T_WALLOP
346 michael 1228 %token T_RESTART
347 michael 1157 %token T_SERVICE
348 michael 1176 %token T_SERVICES_NAME
349 adx 30 %token THROTTLE_TIME
350     %token TOPICBURST
351     %token TRUE_NO_OPER_FLOOD
352     %token TKLINE
353     %token TXLINE
354     %token TRESV
355     %token UNKLINE
356     %token USER
357     %token USE_EGD
358     %token USE_EXCEPT
359     %token USE_INVEX
360     %token USE_KNOCK
361     %token USE_LOGGING
362     %token USE_WHOIS_ACTUALLY
363     %token VHOST
364     %token VHOST6
365     %token XLINE
366     %token WARN
367     %token WARN_NO_NLINE
368 michael 1247 %token T_SIZE
369     %token T_FILE
370 adx 30
371     %type <string> QSTRING
372     %type <number> NUMBER
373     %type <number> timespec
374     %type <number> timespec_
375     %type <number> sizespec
376     %type <number> sizespec_
377    
378     %%
379     conf:
380     | conf conf_item
381     ;
382    
383     conf_item: admin_entry
384     | logging_entry
385     | oper_entry
386     | channel_entry
387     | class_entry
388     | listen_entry
389     | auth_entry
390     | serverinfo_entry
391     | serverhide_entry
392     | resv_entry
393 michael 1157 | service_entry
394 adx 30 | shared_entry
395     | cluster_entry
396     | connect_entry
397     | kill_entry
398     | deny_entry
399     | exempt_entry
400     | general_entry
401     | gline_entry
402     | gecos_entry
403     | modules_entry
404     | error ';'
405     | error '}'
406     ;
407    
408    
409     timespec_: { $$ = 0; } | timespec;
410     timespec: NUMBER timespec_
411     {
412     $$ = $1 + $2;
413     }
414     | NUMBER SECONDS timespec_
415     {
416     $$ = $1 + $3;
417     }
418     | NUMBER MINUTES timespec_
419     {
420     $$ = $1 * 60 + $3;
421     }
422     | NUMBER HOURS timespec_
423     {
424     $$ = $1 * 60 * 60 + $3;
425     }
426     | NUMBER DAYS timespec_
427     {
428     $$ = $1 * 60 * 60 * 24 + $3;
429     }
430     | NUMBER WEEKS timespec_
431     {
432     $$ = $1 * 60 * 60 * 24 * 7 + $3;
433     }
434     ;
435    
436     sizespec_: { $$ = 0; } | sizespec;
437     sizespec: NUMBER sizespec_ { $$ = $1 + $2; }
438     | NUMBER BYTES sizespec_ { $$ = $1 + $3; }
439     | NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; }
440     | NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
441     ;
442    
443    
444     /***************************************************************************
445     * section modules
446     ***************************************************************************/
447     modules_entry: MODULES
448     '{' modules_items '}' ';';
449    
450     modules_items: modules_items modules_item | modules_item;
451     modules_item: modules_module | modules_path | error ';' ;
452    
453     modules_module: MODULE '=' QSTRING ';'
454     {
455 michael 967 if (conf_parser_ctx.pass == 2)
456 michael 978 add_conf_module(libio_basename(yylval.string));
457 adx 30 };
458    
459     modules_path: PATH '=' QSTRING ';'
460     {
461 michael 967 if (conf_parser_ctx.pass == 2)
462 adx 30 mod_add_path(yylval.string);
463     };
464    
465    
466 michael 967 serverinfo_entry: SERVERINFO '{' serverinfo_items '}' ';';
467    
468     serverinfo_items: serverinfo_items serverinfo_item | serverinfo_item ;
469 adx 30 serverinfo_item: serverinfo_name | serverinfo_vhost |
470     serverinfo_hub | serverinfo_description |
471     serverinfo_network_name | serverinfo_network_desc |
472 michael 1306 serverinfo_max_clients | serverinfo_ssl_dh_param_file |
473 adx 30 serverinfo_rsa_private_key_file | serverinfo_vhost6 |
474     serverinfo_sid | serverinfo_ssl_certificate_file |
475 michael 1316 serverinfo_ssl_client_method | serverinfo_ssl_server_method |
476     serverinfo_ssl_cipher_list |
477 adx 30 error ';' ;
478    
479 michael 967
480 michael 1316 serverinfo_ssl_client_method: T_SSL_CLIENT_METHOD '=' client_method_types ';' ;
481     serverinfo_ssl_server_method: T_SSL_SERVER_METHOD '=' server_method_types ';' ;
482    
483     client_method_types: client_method_types ',' client_method_type_item | client_method_type_item;
484     client_method_type_item: T_SSLV3
485 michael 967 {
486 michael 1024 #ifdef HAVE_LIBCRYPTO
487 michael 1316 if (conf_parser_ctx.pass == 2 && ServerInfo.client_ctx)
488     SSL_CTX_clear_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv3);
489 michael 1024 #endif
490 michael 1316 } | T_TLSV1
491 michael 967 {
492 michael 1024 #ifdef HAVE_LIBCRYPTO
493 michael 1316 if (conf_parser_ctx.pass == 2 && ServerInfo.client_ctx)
494     SSL_CTX_clear_options(ServerInfo.client_ctx, SSL_OP_NO_TLSv1);
495 michael 1024 #endif
496 michael 967 };
497    
498 michael 1316 server_method_types: server_method_types ',' server_method_type_item | server_method_type_item;
499     server_method_type_item: T_SSLV3
500 michael 967 {
501 michael 1024 #ifdef HAVE_LIBCRYPTO
502 michael 1316 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
503     SSL_CTX_clear_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv3);
504 michael 1024 #endif
505 michael 967 } | T_TLSV1
506     {
507 michael 1024 #ifdef HAVE_LIBCRYPTO
508 michael 1316 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
509     SSL_CTX_clear_options(ServerInfo.server_ctx, SSL_OP_NO_TLSv1);
510 michael 1024 #endif
511 michael 967 };
512    
513 adx 30 serverinfo_ssl_certificate_file: SSL_CERTIFICATE_FILE '=' QSTRING ';'
514     {
515     #ifdef HAVE_LIBCRYPTO
516 michael 967 if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
517 adx 30 {
518     if (!ServerInfo.rsa_private_key_file)
519     {
520     yyerror("No rsa_private_key_file specified, SSL disabled");
521     break;
522     }
523    
524 michael 967 if (SSL_CTX_use_certificate_file(ServerInfo.server_ctx, yylval.string,
525 michael 1303 SSL_FILETYPE_PEM) <= 0 ||
526     SSL_CTX_use_certificate_file(ServerInfo.client_ctx, yylval.string,
527 michael 967 SSL_FILETYPE_PEM) <= 0)
528 adx 30 {
529     yyerror(ERR_lib_error_string(ERR_get_error()));
530     break;
531     }
532    
533 michael 967 if (SSL_CTX_use_PrivateKey_file(ServerInfo.server_ctx, ServerInfo.rsa_private_key_file,
534 michael 1303 SSL_FILETYPE_PEM) <= 0 ||
535     SSL_CTX_use_PrivateKey_file(ServerInfo.client_ctx, ServerInfo.rsa_private_key_file,
536 michael 967 SSL_FILETYPE_PEM) <= 0)
537 adx 30 {
538     yyerror(ERR_lib_error_string(ERR_get_error()));
539     break;
540     }
541    
542 michael 1303 if (!SSL_CTX_check_private_key(ServerInfo.server_ctx) ||
543     !SSL_CTX_check_private_key(ServerInfo.client_ctx))
544 adx 30 {
545 michael 967 yyerror(ERR_lib_error_string(ERR_get_error()));
546 adx 30 break;
547     }
548     }
549     #endif
550     };
551    
552     serverinfo_rsa_private_key_file: RSA_PRIVATE_KEY_FILE '=' QSTRING ';'
553     {
554     #ifdef HAVE_LIBCRYPTO
555 michael 967 if (conf_parser_ctx.pass == 1)
556 adx 30 {
557     BIO *file;
558    
559     if (ServerInfo.rsa_private_key)
560     {
561     RSA_free(ServerInfo.rsa_private_key);
562     ServerInfo.rsa_private_key = NULL;
563     }
564    
565     if (ServerInfo.rsa_private_key_file)
566     {
567     MyFree(ServerInfo.rsa_private_key_file);
568     ServerInfo.rsa_private_key_file = NULL;
569     }
570    
571     DupString(ServerInfo.rsa_private_key_file, yylval.string);
572    
573     if ((file = BIO_new_file(yylval.string, "r")) == NULL)
574     {
575     yyerror("File open failed, ignoring");
576     break;
577     }
578    
579 michael 1306 ServerInfo.rsa_private_key = PEM_read_bio_RSAPrivateKey(file, NULL, 0, NULL);
580 adx 30
581     BIO_set_close(file, BIO_CLOSE);
582     BIO_free(file);
583    
584     if (ServerInfo.rsa_private_key == NULL)
585     {
586     yyerror("Couldn't extract key, ignoring");
587     break;
588     }
589    
590     if (!RSA_check_key(ServerInfo.rsa_private_key))
591     {
592     RSA_free(ServerInfo.rsa_private_key);
593     ServerInfo.rsa_private_key = NULL;
594    
595     yyerror("Invalid key, ignoring");
596     break;
597     }
598    
599     /* require 2048 bit (256 byte) key */
600     if (RSA_size(ServerInfo.rsa_private_key) != 256)
601     {
602     RSA_free(ServerInfo.rsa_private_key);
603     ServerInfo.rsa_private_key = NULL;
604    
605     yyerror("Not a 2048 bit key, ignoring");
606     }
607     }
608     #endif
609     };
610    
611 michael 1306 serverinfo_ssl_dh_param_file: SSL_DH_PARAM_FILE '=' QSTRING ';'
612     {
613     /* TBD - XXX: error reporting */
614     #ifdef HAVE_LIBCRYPTO
615     if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
616     {
617     BIO *file = BIO_new_file(yylval.string, "r");
618    
619     if (file)
620     {
621     DH *dh = PEM_read_bio_DHparams(file, NULL, NULL, NULL);
622    
623     BIO_free(file);
624    
625     if (dh)
626     {
627 michael 1352 if (DH_size(dh) < 128)
628     ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::ssl_dh_param_file -- need at least a 1024 bit DH prime size");
629     else
630     SSL_CTX_set_tmp_dh(ServerInfo.server_ctx, dh);
631    
632 michael 1306 DH_free(dh);
633     }
634     }
635     }
636     #endif
637     };
638    
639     serverinfo_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
640     {
641     #ifdef HAVE_LIBCRYPTO
642     if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
643     SSL_CTX_set_cipher_list(ServerInfo.server_ctx, yylval.string);
644     #endif
645     };
646    
647 adx 30 serverinfo_name: NAME '=' QSTRING ';'
648     {
649     /* this isn't rehashable */
650 michael 1117 if (conf_parser_ctx.pass == 2 && !ServerInfo.name)
651 adx 30 {
652 michael 1117 if (valid_servname(yylval.string))
653     DupString(ServerInfo.name, yylval.string);
654     else
655 adx 30 {
656 michael 1247 ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::name -- invalid name. Aborting.");
657 michael 1117 exit(0);
658 adx 30 }
659     }
660     };
661    
662     serverinfo_sid: IRCD_SID '=' QSTRING ';'
663     {
664     /* this isn't rehashable */
665 michael 967 if (conf_parser_ctx.pass == 2 && !ServerInfo.sid)
666 adx 30 {
667 michael 573 if (valid_sid(yylval.string))
668 adx 30 DupString(ServerInfo.sid, yylval.string);
669     else
670     {
671 michael 1247 ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::sid -- invalid SID. Aborting.");
672 adx 30 exit(0);
673     }
674     }
675     };
676    
677     serverinfo_description: DESCRIPTION '=' QSTRING ';'
678     {
679 michael 967 if (conf_parser_ctx.pass == 2)
680 adx 30 {
681     MyFree(ServerInfo.description);
682     DupString(ServerInfo.description,yylval.string);
683     }
684     };
685    
686     serverinfo_network_name: NETWORK_NAME '=' QSTRING ';'
687     {
688 michael 967 if (conf_parser_ctx.pass == 2)
689 adx 30 {
690     char *p;
691    
692     if ((p = strchr(yylval.string, ' ')) != NULL)
693     p = '\0';
694    
695     MyFree(ServerInfo.network_name);
696     DupString(ServerInfo.network_name, yylval.string);
697     }
698     };
699    
700     serverinfo_network_desc: NETWORK_DESC '=' QSTRING ';'
701     {
702 michael 967 if (conf_parser_ctx.pass == 2)
703 adx 30 {
704     MyFree(ServerInfo.network_desc);
705     DupString(ServerInfo.network_desc, yylval.string);
706     }
707     };
708    
709     serverinfo_vhost: VHOST '=' QSTRING ';'
710     {
711 michael 967 if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
712 adx 30 {
713     struct addrinfo hints, *res;
714    
715     memset(&hints, 0, sizeof(hints));
716    
717     hints.ai_family = AF_UNSPEC;
718     hints.ai_socktype = SOCK_STREAM;
719     hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
720    
721 michael 1123 if (getaddrinfo(yylval.string, NULL, &hints, &res))
722 michael 1247 ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
723 adx 30 else
724     {
725     assert(res != NULL);
726    
727     memcpy(&ServerInfo.ip, res->ai_addr, res->ai_addrlen);
728     ServerInfo.ip.ss.ss_family = res->ai_family;
729     ServerInfo.ip.ss_len = res->ai_addrlen;
730 michael 1123 freeaddrinfo(res);
731 adx 30
732     ServerInfo.specific_ipv4_vhost = 1;
733     }
734     }
735     };
736    
737     serverinfo_vhost6: VHOST6 '=' QSTRING ';'
738     {
739     #ifdef IPV6
740 michael 967 if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
741 adx 30 {
742     struct addrinfo hints, *res;
743    
744     memset(&hints, 0, sizeof(hints));
745    
746     hints.ai_family = AF_UNSPEC;
747     hints.ai_socktype = SOCK_STREAM;
748     hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
749    
750 michael 1123 if (getaddrinfo(yylval.string, NULL, &hints, &res))
751 michael 1247 ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost6(%s)", yylval.string);
752 adx 30 else
753     {
754     assert(res != NULL);
755    
756     memcpy(&ServerInfo.ip6, res->ai_addr, res->ai_addrlen);
757     ServerInfo.ip6.ss.ss_family = res->ai_family;
758     ServerInfo.ip6.ss_len = res->ai_addrlen;
759 michael 1123 freeaddrinfo(res);
760 adx 30
761     ServerInfo.specific_ipv6_vhost = 1;
762     }
763     }
764     #endif
765     };
766    
767     serverinfo_max_clients: T_MAX_CLIENTS '=' NUMBER ';'
768     {
769 michael 967 if (conf_parser_ctx.pass == 2)
770 adx 30 {
771     recalc_fdlimit(NULL);
772    
773     if ($3 < MAXCLIENTS_MIN)
774     {
775     char buf[IRCD_BUFSIZE];
776     ircsprintf(buf, "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
777     yyerror(buf);
778     }
779     else if ($3 > MAXCLIENTS_MAX)
780     {
781     char buf[IRCD_BUFSIZE];
782     ircsprintf(buf, "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
783     yyerror(buf);
784     }
785     else
786     ServerInfo.max_clients = $3;
787     }
788     };
789    
790     serverinfo_hub: HUB '=' TBOOL ';'
791     {
792 michael 967 if (conf_parser_ctx.pass == 2)
793 michael 1119 ServerInfo.hub = yylval.number;
794 adx 30 };
795    
796     /***************************************************************************
797     * admin section
798     ***************************************************************************/
799     admin_entry: ADMIN '{' admin_items '}' ';' ;
800    
801     admin_items: admin_items admin_item | admin_item;
802     admin_item: admin_name | admin_description |
803     admin_email | error ';' ;
804    
805     admin_name: NAME '=' QSTRING ';'
806     {
807 michael 967 if (conf_parser_ctx.pass == 2)
808 adx 30 {
809     MyFree(AdminInfo.name);
810     DupString(AdminInfo.name, yylval.string);
811     }
812     };
813    
814     admin_email: EMAIL '=' QSTRING ';'
815     {
816 michael 967 if (conf_parser_ctx.pass == 2)
817 adx 30 {
818     MyFree(AdminInfo.email);
819     DupString(AdminInfo.email, yylval.string);
820     }
821     };
822    
823     admin_description: DESCRIPTION '=' QSTRING ';'
824     {
825 michael 967 if (conf_parser_ctx.pass == 2)
826 adx 30 {
827     MyFree(AdminInfo.description);
828     DupString(AdminInfo.description, yylval.string);
829     }
830     };
831    
832     /***************************************************************************
833     * section logging
834     ***************************************************************************/
835 michael 1247 logging_entry: T_LOG '{' logging_items '}' ';' ;
836     logging_items: logging_items logging_item | logging_item ;
837 adx 30
838 michael 1324 logging_item: logging_use_logging | logging_file_entry |
839 adx 30 error ';' ;
840    
841 michael 1247 logging_use_logging: USE_LOGGING '=' TBOOL ';'
842 adx 30 {
843 michael 967 if (conf_parser_ctx.pass == 2)
844 michael 1247 ConfigLoggingEntry.use_logging = yylval.number;
845 adx 30 };
846    
847 michael 1247 logging_file_entry:
848 adx 30 {
849 michael 1247 lfile[0] = '\0';
850     ltype = 0;
851     lsize = 0;
852     } T_FILE '{' logging_file_items '}' ';'
853 adx 30 {
854 michael 1248 if (conf_parser_ctx.pass == 2 && ltype > 0)
855 michael 1247 log_add_file(ltype, lsize, lfile);
856 adx 30 };
857    
858 michael 1247 logging_file_items: logging_file_items logging_file_item |
859     logging_file_item ;
860 adx 30
861 michael 1247 logging_file_item: logging_file_name | logging_file_type |
862     logging_file_size | error ';' ;
863    
864     logging_file_name: NAME '=' QSTRING ';'
865 adx 30 {
866 michael 1247 strlcpy(lfile, yylval.string, sizeof(lfile));
867     }
868 adx 30
869 michael 1247 logging_file_size: T_SIZE '=' sizespec ';'
870 adx 30 {
871 michael 1247 lsize = $3;
872 michael 1250 } | T_SIZE '=' T_UNLIMITED ';'
873     {
874     lsize = 0;
875 adx 30 };
876    
877 michael 1247 logging_file_type: TYPE
878 adx 30 {
879 michael 967 if (conf_parser_ctx.pass == 2)
880 michael 1247 ltype = 0;
881     } '=' logging_file_type_items ';' ;
882 adx 30
883 michael 1247 logging_file_type_items: logging_file_type_items ',' logging_file_type_item | logging_file_type_item;
884     logging_file_type_item: USER
885 adx 30 {
886 michael 967 if (conf_parser_ctx.pass == 2)
887 michael 1247 ltype = LOG_TYPE_USER;
888     } | OPERATOR
889 adx 30 {
890 michael 967 if (conf_parser_ctx.pass == 2)
891 michael 1247 ltype = LOG_TYPE_OPER;
892     } | GLINE
893 adx 30 {
894 michael 967 if (conf_parser_ctx.pass == 2)
895 michael 1247 ltype = LOG_TYPE_GLINE;
896     } | T_DLINE
897 adx 30 {
898 michael 967 if (conf_parser_ctx.pass == 2)
899 michael 1247 ltype = LOG_TYPE_DLINE;
900     } | KLINE
901 adx 30 {
902 michael 967 if (conf_parser_ctx.pass == 2)
903 michael 1247 ltype = LOG_TYPE_KLINE;
904     } | KILL
905 adx 30 {
906 michael 967 if (conf_parser_ctx.pass == 2)
907 michael 1247 ltype = LOG_TYPE_KILL;
908     } | T_DEBUG
909 adx 30 {
910 michael 967 if (conf_parser_ctx.pass == 2)
911 michael 1247 ltype = LOG_TYPE_DEBUG;
912 adx 30 };
913    
914 michael 1247
915 adx 30 /***************************************************************************
916     * section oper
917     ***************************************************************************/
918     oper_entry: OPERATOR
919     {
920 michael 967 if (conf_parser_ctx.pass == 2)
921 adx 30 {
922     yy_conf = make_conf_item(OPER_TYPE);
923     yy_aconf = map_to_conf(yy_conf);
924     SetConfEncrypted(yy_aconf); /* Yes, the default is encrypted */
925     }
926     else
927     {
928     MyFree(class_name);
929     class_name = NULL;
930     }
931 michael 1285 } '{' oper_items '}' ';'
932 adx 30 {
933 michael 967 if (conf_parser_ctx.pass == 2)
934 adx 30 {
935     struct CollectItem *yy_tmp;
936     dlink_node *ptr;
937     dlink_node *next_ptr;
938    
939     conf_add_class_to_conf(yy_conf, class_name);
940    
941     /* Now, make sure there is a copy of the "base" given oper
942     * block in each of the collected copies
943     */
944    
945     DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
946     {
947     struct AccessItem *new_aconf;
948     struct ConfItem *new_conf;
949     yy_tmp = ptr->data;
950    
951     new_conf = make_conf_item(OPER_TYPE);
952     new_aconf = (struct AccessItem *)map_to_conf(new_conf);
953    
954     new_aconf->flags = yy_aconf->flags;
955    
956     if (yy_conf->name != NULL)
957     DupString(new_conf->name, yy_conf->name);
958     if (yy_tmp->user != NULL)
959     DupString(new_aconf->user, yy_tmp->user);
960     else
961     DupString(new_aconf->user, "*");
962     if (yy_tmp->host != NULL)
963     DupString(new_aconf->host, yy_tmp->host);
964     else
965     DupString(new_aconf->host, "*");
966 michael 1285
967     new_aconf->type = parse_netmask(new_aconf->host, &new_aconf->ipnum,
968     &new_aconf->bits);
969    
970 adx 30 conf_add_class_to_conf(new_conf, class_name);
971     if (yy_aconf->passwd != NULL)
972     DupString(new_aconf->passwd, yy_aconf->passwd);
973    
974     new_aconf->port = yy_aconf->port;
975     #ifdef HAVE_LIBCRYPTO
976     if (yy_aconf->rsa_public_key_file != NULL)
977     {
978     BIO *file;
979    
980     DupString(new_aconf->rsa_public_key_file,
981     yy_aconf->rsa_public_key_file);
982    
983     file = BIO_new_file(yy_aconf->rsa_public_key_file, "r");
984     new_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file,
985     NULL, 0, NULL);
986     BIO_set_close(file, BIO_CLOSE);
987     BIO_free(file);
988     }
989     #endif
990    
991     #ifdef HAVE_LIBCRYPTO
992     if (yy_tmp->name && (yy_tmp->passwd || yy_aconf->rsa_public_key)
993     && yy_tmp->host)
994     #else
995     if (yy_tmp->name && yy_tmp->passwd && yy_tmp->host)
996     #endif
997     {
998     conf_add_class_to_conf(new_conf, class_name);
999     if (yy_tmp->name != NULL)
1000     DupString(new_conf->name, yy_tmp->name);
1001     }
1002    
1003     dlinkDelete(&yy_tmp->node, &col_conf_list);
1004     free_collect_item(yy_tmp);
1005     }
1006    
1007     yy_conf = NULL;
1008     yy_aconf = NULL;
1009    
1010    
1011     MyFree(class_name);
1012     class_name = NULL;
1013     }
1014     };
1015    
1016     oper_items: oper_items oper_item | oper_item;
1017 michael 1076 oper_item: oper_name | oper_user | oper_password |
1018     oper_umodes | oper_class | oper_encrypted |
1019     oper_rsa_public_key_file | oper_flags | error ';' ;
1020 adx 30
1021     oper_name: NAME '=' QSTRING ';'
1022     {
1023 michael 967 if (conf_parser_ctx.pass == 2)
1024 adx 30 {
1025     if (strlen(yylval.string) > OPERNICKLEN)
1026     yylval.string[OPERNICKLEN] = '\0';
1027    
1028     MyFree(yy_conf->name);
1029     DupString(yy_conf->name, yylval.string);
1030     }
1031     };
1032    
1033     oper_user: USER '=' QSTRING ';'
1034     {
1035 michael 967 if (conf_parser_ctx.pass == 2)
1036 adx 30 {
1037 michael 593 struct split_nuh_item nuh;
1038 adx 30
1039 michael 593 nuh.nuhmask = yylval.string;
1040     nuh.nickptr = NULL;
1041     nuh.userptr = userbuf;
1042     nuh.hostptr = hostbuf;
1043    
1044     nuh.nicksize = 0;
1045     nuh.usersize = sizeof(userbuf);
1046     nuh.hostsize = sizeof(hostbuf);
1047    
1048     split_nuh(&nuh);
1049    
1050 adx 30 if (yy_aconf->user == NULL)
1051     {
1052 michael 593 DupString(yy_aconf->user, userbuf);
1053     DupString(yy_aconf->host, hostbuf);
1054 michael 1285
1055     yy_aconf->type = parse_netmask(yy_aconf->host, &yy_aconf->ipnum,
1056     &yy_aconf->bits);
1057 adx 30 }
1058     else
1059     {
1060 michael 593 struct CollectItem *yy_tmp = MyMalloc(sizeof(struct CollectItem));
1061    
1062     DupString(yy_tmp->user, userbuf);
1063     DupString(yy_tmp->host, hostbuf);
1064    
1065 adx 30 dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
1066     }
1067     }
1068     };
1069    
1070     oper_password: PASSWORD '=' QSTRING ';'
1071     {
1072 michael 967 if (conf_parser_ctx.pass == 2)
1073 adx 30 {
1074     if (yy_aconf->passwd != NULL)
1075     memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
1076    
1077     MyFree(yy_aconf->passwd);
1078     DupString(yy_aconf->passwd, yylval.string);
1079     }
1080     };
1081    
1082     oper_encrypted: ENCRYPTED '=' TBOOL ';'
1083     {
1084 michael 967 if (conf_parser_ctx.pass == 2)
1085 adx 30 {
1086     if (yylval.number)
1087     SetConfEncrypted(yy_aconf);
1088     else
1089     ClearConfEncrypted(yy_aconf);
1090     }
1091     };
1092    
1093     oper_rsa_public_key_file: RSA_PUBLIC_KEY_FILE '=' QSTRING ';'
1094     {
1095     #ifdef HAVE_LIBCRYPTO
1096 michael 967 if (conf_parser_ctx.pass == 2)
1097 adx 30 {
1098     BIO *file;
1099    
1100     if (yy_aconf->rsa_public_key != NULL)
1101     {
1102     RSA_free(yy_aconf->rsa_public_key);
1103     yy_aconf->rsa_public_key = NULL;
1104     }
1105    
1106     if (yy_aconf->rsa_public_key_file != NULL)
1107     {
1108     MyFree(yy_aconf->rsa_public_key_file);
1109     yy_aconf->rsa_public_key_file = NULL;
1110     }
1111    
1112     DupString(yy_aconf->rsa_public_key_file, yylval.string);
1113     file = BIO_new_file(yylval.string, "r");
1114    
1115     if (file == NULL)
1116     {
1117     yyerror("Ignoring rsa_public_key_file -- file doesn't exist");
1118     break;
1119     }
1120    
1121     yy_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
1122    
1123     if (yy_aconf->rsa_public_key == NULL)
1124     {
1125     yyerror("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
1126     break;
1127     }
1128    
1129     BIO_set_close(file, BIO_CLOSE);
1130     BIO_free(file);
1131     }
1132     #endif /* HAVE_LIBCRYPTO */
1133     };
1134    
1135     oper_class: CLASS '=' QSTRING ';'
1136     {
1137 michael 967 if (conf_parser_ctx.pass == 2)
1138 adx 30 {
1139     MyFree(class_name);
1140     DupString(class_name, yylval.string);
1141     }
1142     };
1143    
1144 michael 56 oper_umodes: T_UMODES
1145     {
1146 michael 967 if (conf_parser_ctx.pass == 2)
1147 db 298 yy_aconf->modes = 0;
1148 michael 56 } '=' oper_umodes_items ';' ;
1149    
1150     oper_umodes_items: oper_umodes_items ',' oper_umodes_item | oper_umodes_item;
1151     oper_umodes_item: T_BOTS
1152     {
1153 michael 967 if (conf_parser_ctx.pass == 2)
1154 db 298 yy_aconf->modes |= UMODE_BOTS;
1155 michael 56 } | T_CCONN
1156     {
1157 michael 967 if (conf_parser_ctx.pass == 2)
1158 db 298 yy_aconf->modes |= UMODE_CCONN;
1159 db 849 } | T_CCONN_FULL
1160     {
1161 michael 967 if (conf_parser_ctx.pass == 2)
1162 db 849 yy_aconf->modes |= UMODE_CCONN_FULL;
1163 michael 56 } | T_DEAF
1164     {
1165 michael 967 if (conf_parser_ctx.pass == 2)
1166 db 298 yy_aconf->modes |= UMODE_DEAF;
1167 michael 56 } | T_DEBUG
1168     {
1169 michael 967 if (conf_parser_ctx.pass == 2)
1170 db 298 yy_aconf->modes |= UMODE_DEBUG;
1171 michael 56 } | T_FULL
1172     {
1173 michael 967 if (conf_parser_ctx.pass == 2)
1174 db 298 yy_aconf->modes |= UMODE_FULL;
1175 michael 1294 } | HIDDEN
1176     {
1177     if (conf_parser_ctx.pass == 2)
1178     yy_aconf->modes |= UMODE_HIDDEN;
1179 michael 56 } | T_SKILL
1180     {
1181 michael 967 if (conf_parser_ctx.pass == 2)
1182 db 298 yy_aconf->modes |= UMODE_SKILL;
1183 michael 56 } | T_NCHANGE
1184     {
1185 michael 967 if (conf_parser_ctx.pass == 2)
1186 db 298 yy_aconf->modes |= UMODE_NCHANGE;
1187 michael 56 } | T_REJ
1188     {
1189 michael 967 if (conf_parser_ctx.pass == 2)
1190 db 298 yy_aconf->modes |= UMODE_REJ;
1191 michael 56 } | T_UNAUTH
1192     {
1193 michael 967 if (conf_parser_ctx.pass == 2)
1194 db 298 yy_aconf->modes |= UMODE_UNAUTH;
1195 michael 56 } | T_SPY
1196     {
1197 michael 967 if (conf_parser_ctx.pass == 2)
1198 db 298 yy_aconf->modes |= UMODE_SPY;
1199 michael 56 } | T_EXTERNAL
1200     {
1201 michael 967 if (conf_parser_ctx.pass == 2)
1202 db 298 yy_aconf->modes |= UMODE_EXTERNAL;
1203 michael 56 } | T_OPERWALL
1204     {
1205 michael 967 if (conf_parser_ctx.pass == 2)
1206 db 298 yy_aconf->modes |= UMODE_OPERWALL;
1207 michael 56 } | T_SERVNOTICE
1208     {
1209 michael 967 if (conf_parser_ctx.pass == 2)
1210 db 298 yy_aconf->modes |= UMODE_SERVNOTICE;
1211 michael 56 } | T_INVISIBLE
1212     {
1213 michael 967 if (conf_parser_ctx.pass == 2)
1214 db 298 yy_aconf->modes |= UMODE_INVISIBLE;
1215 michael 56 } | T_WALLOP
1216     {
1217 michael 967 if (conf_parser_ctx.pass == 2)
1218 db 298 yy_aconf->modes |= UMODE_WALLOP;
1219 michael 56 } | T_SOFTCALLERID
1220     {
1221 michael 967 if (conf_parser_ctx.pass == 2)
1222 db 298 yy_aconf->modes |= UMODE_SOFTCALLERID;
1223 michael 56 } | T_CALLERID
1224     {
1225 michael 967 if (conf_parser_ctx.pass == 2)
1226 db 298 yy_aconf->modes |= UMODE_CALLERID;
1227 michael 56 } | T_LOCOPS
1228     {
1229 michael 967 if (conf_parser_ctx.pass == 2)
1230 db 298 yy_aconf->modes |= UMODE_LOCOPS;
1231 michael 56 };
1232    
1233 adx 30 oper_flags: IRCD_FLAGS
1234     {
1235 michael 1228 if (conf_parser_ctx.pass == 2)
1236     yy_aconf->port = 0;
1237 adx 30 } '=' oper_flags_items ';';
1238    
1239     oper_flags_items: oper_flags_items ',' oper_flags_item | oper_flags_item;
1240 michael 1228 oper_flags_item: GLOBAL_KILL
1241 adx 30 {
1242 michael 967 if (conf_parser_ctx.pass == 2)
1243 michael 1228 yy_aconf->port |= OPER_FLAG_GLOBAL_KILL;
1244 adx 30 } | REMOTE
1245     {
1246 michael 967 if (conf_parser_ctx.pass == 2)
1247 michael 1228 yy_aconf->port |= OPER_FLAG_REMOTE;
1248 adx 30 } | KLINE
1249     {
1250 michael 967 if (conf_parser_ctx.pass == 2)
1251 michael 1228 yy_aconf->port |= OPER_FLAG_K;
1252 adx 30 } | UNKLINE
1253     {
1254 michael 967 if (conf_parser_ctx.pass == 2)
1255 michael 1228 yy_aconf->port |= OPER_FLAG_UNKLINE;
1256 michael 1301 } | T_DLINE
1257     {
1258     if (conf_parser_ctx.pass == 2)
1259     yy_aconf->port |= OPER_FLAG_DLINE;
1260     } | T_UNDLINE
1261     {
1262     if (conf_parser_ctx.pass == 2)
1263     yy_aconf->port |= OPER_FLAG_UNDLINE;
1264 adx 30 } | XLINE
1265     {
1266 michael 967 if (conf_parser_ctx.pass == 2)
1267 michael 1228 yy_aconf->port |= OPER_FLAG_X;
1268 adx 30 } | GLINE
1269     {
1270 michael 967 if (conf_parser_ctx.pass == 2)
1271 michael 1228 yy_aconf->port |= OPER_FLAG_GLINE;
1272 adx 30 } | DIE
1273     {
1274 michael 967 if (conf_parser_ctx.pass == 2)
1275 michael 1228 yy_aconf->port |= OPER_FLAG_DIE;
1276     } | T_RESTART
1277     {
1278     if (conf_parser_ctx.pass == 2)
1279     yy_aconf->port |= OPER_FLAG_RESTART;
1280 adx 30 } | REHASH
1281     {
1282 michael 967 if (conf_parser_ctx.pass == 2)
1283 michael 1228 yy_aconf->port |= OPER_FLAG_REHASH;
1284 adx 30 } | ADMIN
1285     {
1286 michael 967 if (conf_parser_ctx.pass == 2)
1287 michael 1228 yy_aconf->port |= OPER_FLAG_ADMIN;
1288 adx 30 } | NICK_CHANGES
1289     {
1290 michael 967 if (conf_parser_ctx.pass == 2)
1291 michael 1228 yy_aconf->port |= OPER_FLAG_N;
1292 adx 30 } | T_OPERWALL
1293     {
1294 michael 967 if (conf_parser_ctx.pass == 2)
1295 michael 1228 yy_aconf->port |= OPER_FLAG_OPERWALL;
1296 michael 1216 } | T_GLOBOPS
1297     {
1298     if (conf_parser_ctx.pass == 2)
1299 michael 1228 yy_aconf->port |= OPER_FLAG_GLOBOPS;
1300 adx 30 } | OPER_SPY_T
1301     {
1302 michael 967 if (conf_parser_ctx.pass == 2)
1303 michael 1228 yy_aconf->port |= OPER_FLAG_OPER_SPY;
1304 adx 30 } | REMOTEBAN
1305     {
1306 michael 967 if (conf_parser_ctx.pass == 2)
1307 michael 1228 yy_aconf->port |= OPER_FLAG_REMOTEBAN;
1308     } | MODULE
1309 adx 30 {
1310 michael 967 if (conf_parser_ctx.pass == 2)
1311 michael 1228 yy_aconf->port |= OPER_FLAG_MODULE;
1312 adx 30 };
1313    
1314    
1315     /***************************************************************************
1316     * section class
1317     ***************************************************************************/
1318     class_entry: CLASS
1319     {
1320 michael 967 if (conf_parser_ctx.pass == 1)
1321 adx 30 {
1322     yy_conf = make_conf_item(CLASS_TYPE);
1323 michael 671 yy_class = map_to_conf(yy_conf);
1324 adx 30 }
1325 michael 1285 } '{' class_items '}' ';'
1326 adx 30 {
1327 michael 967 if (conf_parser_ctx.pass == 1)
1328 adx 30 {
1329 michael 671 struct ConfItem *cconf = NULL;
1330 adx 30 struct ClassItem *class = NULL;
1331    
1332     if (yy_class_name == NULL)
1333     delete_conf_item(yy_conf);
1334     else
1335     {
1336 michael 1285 cconf = find_exact_name_conf(CLASS_TYPE, NULL, yy_class_name, NULL, NULL);
1337 adx 30
1338     if (cconf != NULL) /* The class existed already */
1339     {
1340 michael 671 int user_count = 0;
1341    
1342 adx 30 rebuild_cidr_class(cconf, yy_class);
1343 michael 671
1344     class = map_to_conf(cconf);
1345    
1346     user_count = class->curr_user_count;
1347     memcpy(class, yy_class, sizeof(*class));
1348     class->curr_user_count = user_count;
1349     class->active = 1;
1350    
1351 adx 30 delete_conf_item(yy_conf);
1352    
1353     MyFree(cconf->name); /* Allows case change of class name */
1354     cconf->name = yy_class_name;
1355     }
1356     else /* Brand new class */
1357     {
1358     MyFree(yy_conf->name); /* just in case it was allocated */
1359     yy_conf->name = yy_class_name;
1360 michael 671 yy_class->active = 1;
1361 adx 30 }
1362     }
1363 michael 671
1364 adx 30 yy_class_name = NULL;
1365     }
1366     };
1367    
1368     class_items: class_items class_item | class_item;
1369     class_item: class_name |
1370     class_cidr_bitlen_ipv4 | class_cidr_bitlen_ipv6 |
1371     class_ping_time |
1372     class_ping_warning |
1373     class_number_per_cidr |
1374     class_number_per_ip |
1375     class_connectfreq |
1376     class_max_number |
1377     class_max_global |
1378     class_max_local |
1379     class_max_ident |
1380     class_sendq |
1381     error ';' ;
1382    
1383     class_name: NAME '=' QSTRING ';'
1384     {
1385 michael 967 if (conf_parser_ctx.pass == 1)
1386 adx 30 {
1387     MyFree(yy_class_name);
1388     DupString(yy_class_name, yylval.string);
1389     }
1390     };
1391    
1392     class_ping_time: PING_TIME '=' timespec ';'
1393     {
1394 michael 967 if (conf_parser_ctx.pass == 1)
1395 adx 30 PingFreq(yy_class) = $3;
1396     };
1397    
1398     class_ping_warning: PING_WARNING '=' timespec ';'
1399     {
1400 michael 967 if (conf_parser_ctx.pass == 1)
1401 adx 30 PingWarning(yy_class) = $3;
1402     };
1403    
1404     class_number_per_ip: NUMBER_PER_IP '=' NUMBER ';'
1405     {
1406 michael 967 if (conf_parser_ctx.pass == 1)
1407 adx 30 MaxPerIp(yy_class) = $3;
1408     };
1409    
1410     class_connectfreq: CONNECTFREQ '=' timespec ';'
1411     {
1412 michael 967 if (conf_parser_ctx.pass == 1)
1413 adx 30 ConFreq(yy_class) = $3;
1414     };
1415    
1416     class_max_number: MAX_NUMBER '=' NUMBER ';'
1417     {
1418 michael 967 if (conf_parser_ctx.pass == 1)
1419 adx 30 MaxTotal(yy_class) = $3;
1420     };
1421    
1422     class_max_global: MAX_GLOBAL '=' NUMBER ';'
1423     {
1424 michael 967 if (conf_parser_ctx.pass == 1)
1425 adx 30 MaxGlobal(yy_class) = $3;
1426     };
1427    
1428     class_max_local: MAX_LOCAL '=' NUMBER ';'
1429     {
1430 michael 967 if (conf_parser_ctx.pass == 1)
1431 adx 30 MaxLocal(yy_class) = $3;
1432     };
1433    
1434     class_max_ident: MAX_IDENT '=' NUMBER ';'
1435     {
1436 michael 967 if (conf_parser_ctx.pass == 1)
1437 adx 30 MaxIdent(yy_class) = $3;
1438     };
1439    
1440     class_sendq: SENDQ '=' sizespec ';'
1441     {
1442 michael 967 if (conf_parser_ctx.pass == 1)
1443 adx 30 MaxSendq(yy_class) = $3;
1444     };
1445    
1446     class_cidr_bitlen_ipv4: CIDR_BITLEN_IPV4 '=' NUMBER ';'
1447     {
1448 michael 967 if (conf_parser_ctx.pass == 1)
1449 adx 30 CidrBitlenIPV4(yy_class) = $3;
1450     };
1451    
1452     class_cidr_bitlen_ipv6: CIDR_BITLEN_IPV6 '=' NUMBER ';'
1453     {
1454 michael 967 if (conf_parser_ctx.pass == 1)
1455 adx 30 CidrBitlenIPV6(yy_class) = $3;
1456     };
1457    
1458     class_number_per_cidr: NUMBER_PER_CIDR '=' NUMBER ';'
1459     {
1460 michael 967 if (conf_parser_ctx.pass == 1)
1461 adx 30 NumberPerCidr(yy_class) = $3;
1462     };
1463    
1464     /***************************************************************************
1465     * section listen
1466     ***************************************************************************/
1467     listen_entry: LISTEN
1468     {
1469 michael 967 if (conf_parser_ctx.pass == 2)
1470 adx 30 {
1471     listener_address = NULL;
1472     listener_flags = 0;
1473     }
1474     } '{' listen_items '}' ';'
1475     {
1476 michael 967 if (conf_parser_ctx.pass == 2)
1477 adx 30 {
1478     MyFree(listener_address);
1479     listener_address = NULL;
1480     }
1481     };
1482    
1483     listen_flags: IRCD_FLAGS
1484     {
1485 michael 440 listener_flags = 0;
1486 adx 30 } '=' listen_flags_items ';';
1487    
1488     listen_flags_items: listen_flags_items ',' listen_flags_item | listen_flags_item;
1489     listen_flags_item: T_SSL
1490     {
1491 michael 967 if (conf_parser_ctx.pass == 2)
1492 adx 30 listener_flags |= LISTENER_SSL;
1493     } | HIDDEN
1494     {
1495 michael 967 if (conf_parser_ctx.pass == 2)
1496 adx 30 listener_flags |= LISTENER_HIDDEN;
1497 michael 900 } | T_SERVER
1498     {
1499 michael 967 if (conf_parser_ctx.pass == 2)
1500 michael 900 listener_flags |= LISTENER_SERVER;
1501 adx 30 };
1502    
1503 michael 900
1504    
1505 adx 30 listen_items: listen_items listen_item | listen_item;
1506 michael 440 listen_item: listen_port | listen_flags | listen_address | listen_host | error ';';
1507 adx 30
1508 michael 440 listen_port: PORT '=' port_items { listener_flags = 0; } ';';
1509 adx 30
1510     port_items: port_items ',' port_item | port_item;
1511    
1512     port_item: NUMBER
1513     {
1514 michael 967 if (conf_parser_ctx.pass == 2)
1515 adx 30 {
1516     if ((listener_flags & LISTENER_SSL))
1517     #ifdef HAVE_LIBCRYPTO
1518 michael 967 if (!ServerInfo.server_ctx)
1519 adx 30 #endif
1520     {
1521     yyerror("SSL not available - port closed");
1522     break;
1523     }
1524     add_listener($1, listener_address, listener_flags);
1525     }
1526     } | NUMBER TWODOTS NUMBER
1527     {
1528 michael 967 if (conf_parser_ctx.pass == 2)
1529 adx 30 {
1530     int i;
1531    
1532     if ((listener_flags & LISTENER_SSL))
1533     #ifdef HAVE_LIBCRYPTO
1534 michael 967 if (!ServerInfo.server_ctx)
1535 adx 30 #endif
1536     {
1537     yyerror("SSL not available - port closed");
1538     break;
1539     }
1540    
1541     for (i = $1; i <= $3; ++i)
1542     add_listener(i, listener_address, listener_flags);
1543     }
1544     };
1545    
1546     listen_address: IP '=' QSTRING ';'
1547     {
1548 michael 967 if (conf_parser_ctx.pass == 2)
1549 adx 30 {
1550     MyFree(listener_address);
1551     DupString(listener_address, yylval.string);
1552     }
1553     };
1554    
1555     listen_host: HOST '=' QSTRING ';'
1556     {
1557 michael 967 if (conf_parser_ctx.pass == 2)
1558 adx 30 {
1559     MyFree(listener_address);
1560     DupString(listener_address, yylval.string);
1561     }
1562     };
1563    
1564     /***************************************************************************
1565     * section auth
1566     ***************************************************************************/
1567     auth_entry: IRCD_AUTH
1568     {
1569 michael 967 if (conf_parser_ctx.pass == 2)
1570 adx 30 {
1571     yy_conf = make_conf_item(CLIENT_TYPE);
1572     yy_aconf = map_to_conf(yy_conf);
1573     }
1574     else
1575     {
1576     MyFree(class_name);
1577     class_name = NULL;
1578     }
1579     } '{' auth_items '}' ';'
1580     {
1581 michael 967 if (conf_parser_ctx.pass == 2)
1582 adx 30 {
1583     struct CollectItem *yy_tmp = NULL;
1584     dlink_node *ptr = NULL, *next_ptr = NULL;
1585    
1586     if (yy_aconf->user && yy_aconf->host)
1587     {
1588     conf_add_class_to_conf(yy_conf, class_name);
1589     add_conf_by_address(CONF_CLIENT, yy_aconf);
1590     }
1591     else
1592     delete_conf_item(yy_conf);
1593    
1594     /* copy over settings from first struct */
1595     DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
1596     {
1597     struct AccessItem *new_aconf;
1598     struct ConfItem *new_conf;
1599    
1600     new_conf = make_conf_item(CLIENT_TYPE);
1601     new_aconf = map_to_conf(new_conf);
1602    
1603     yy_tmp = ptr->data;
1604    
1605     assert(yy_tmp->user && yy_tmp->host);
1606    
1607     if (yy_aconf->passwd != NULL)
1608     DupString(new_aconf->passwd, yy_aconf->passwd);
1609     if (yy_conf->name != NULL)
1610     DupString(new_conf->name, yy_conf->name);
1611     if (yy_aconf->passwd != NULL)
1612     DupString(new_aconf->passwd, yy_aconf->passwd);
1613    
1614     new_aconf->flags = yy_aconf->flags;
1615     new_aconf->port = yy_aconf->port;
1616    
1617     DupString(new_aconf->user, yy_tmp->user);
1618     collapse(new_aconf->user);
1619    
1620     DupString(new_aconf->host, yy_tmp->host);
1621     collapse(new_aconf->host);
1622    
1623     conf_add_class_to_conf(new_conf, class_name);
1624     add_conf_by_address(CONF_CLIENT, new_aconf);
1625     dlinkDelete(&yy_tmp->node, &col_conf_list);
1626     free_collect_item(yy_tmp);
1627     }
1628    
1629     MyFree(class_name);
1630     class_name = NULL;
1631     yy_conf = NULL;
1632     yy_aconf = NULL;
1633     }
1634     };
1635    
1636     auth_items: auth_items auth_item | auth_item;
1637     auth_item: auth_user | auth_passwd | auth_class | auth_flags |
1638 michael 1076 auth_spoof | auth_redir_serv | auth_redir_port |
1639     auth_encrypted | error ';' ;
1640 adx 30
1641     auth_user: USER '=' QSTRING ';'
1642     {
1643 michael 967 if (conf_parser_ctx.pass == 2)
1644 adx 30 {
1645 michael 593 struct CollectItem *yy_tmp = NULL;
1646     struct split_nuh_item nuh;
1647 adx 30
1648 michael 593 nuh.nuhmask = yylval.string;
1649     nuh.nickptr = NULL;
1650     nuh.userptr = userbuf;
1651     nuh.hostptr = hostbuf;
1652    
1653     nuh.nicksize = 0;
1654     nuh.usersize = sizeof(userbuf);
1655     nuh.hostsize = sizeof(hostbuf);
1656    
1657     split_nuh(&nuh);
1658    
1659 adx 30 if (yy_aconf->user == NULL)
1660 michael 593 {
1661     DupString(yy_aconf->user, userbuf);
1662     DupString(yy_aconf->host, hostbuf);
1663     }
1664 adx 30 else
1665     {
1666     yy_tmp = MyMalloc(sizeof(struct CollectItem));
1667 michael 593
1668     DupString(yy_tmp->user, userbuf);
1669     DupString(yy_tmp->host, hostbuf);
1670    
1671 adx 30 dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
1672     }
1673     }
1674     };
1675    
1676     /* XXX - IP/IPV6 tags don't exist anymore - put IP/IPV6 into user. */
1677    
1678     auth_passwd: PASSWORD '=' QSTRING ';'
1679     {
1680 michael 967 if (conf_parser_ctx.pass == 2)
1681 adx 30 {
1682     /* be paranoid */
1683     if (yy_aconf->passwd != NULL)
1684     memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
1685    
1686     MyFree(yy_aconf->passwd);
1687     DupString(yy_aconf->passwd, yylval.string);
1688     }
1689     };
1690    
1691     auth_class: CLASS '=' QSTRING ';'
1692     {
1693 michael 967 if (conf_parser_ctx.pass == 2)
1694 adx 30 {
1695     MyFree(class_name);
1696     DupString(class_name, yylval.string);
1697     }
1698     };
1699    
1700     auth_encrypted: ENCRYPTED '=' TBOOL ';'
1701     {
1702 michael 967 if (conf_parser_ctx.pass == 2)
1703 adx 30 {
1704     if (yylval.number)
1705     SetConfEncrypted(yy_aconf);
1706     else
1707     ClearConfEncrypted(yy_aconf);
1708     }
1709     };
1710    
1711     auth_flags: IRCD_FLAGS
1712     {
1713     } '=' auth_flags_items ';';
1714    
1715     auth_flags_items: auth_flags_items ',' auth_flags_item | auth_flags_item;
1716 michael 1228 auth_flags_item: SPOOF_NOTICE
1717 adx 30 {
1718 michael 967 if (conf_parser_ctx.pass == 2)
1719 michael 1228 yy_aconf->flags |= CONF_FLAGS_SPOOF_NOTICE;
1720 adx 30 } | EXCEED_LIMIT
1721     {
1722 michael 967 if (conf_parser_ctx.pass == 2)
1723 michael 1228 yy_aconf->flags |= CONF_FLAGS_NOLIMIT;
1724 adx 30 } | KLINE_EXEMPT
1725     {
1726 michael 967 if (conf_parser_ctx.pass == 2)
1727 michael 1228 yy_aconf->flags |= CONF_FLAGS_EXEMPTKLINE;
1728 adx 30 } | NEED_IDENT
1729     {
1730 michael 967 if (conf_parser_ctx.pass == 2)
1731 michael 1228 yy_aconf->flags |= CONF_FLAGS_NEED_IDENTD;
1732 adx 30 } | CAN_FLOOD
1733     {
1734 michael 967 if (conf_parser_ctx.pass == 2)
1735 michael 1228 yy_aconf->flags |= CONF_FLAGS_CAN_FLOOD;
1736 adx 30 } | NO_TILDE
1737     {
1738 michael 967 if (conf_parser_ctx.pass == 2)
1739 michael 1228 yy_aconf->flags |= CONF_FLAGS_NO_TILDE;
1740 adx 30 } | GLINE_EXEMPT
1741     {
1742 michael 967 if (conf_parser_ctx.pass == 2)
1743 michael 1228 yy_aconf->flags |= CONF_FLAGS_EXEMPTGLINE;
1744 adx 30 } | RESV_EXEMPT
1745     {
1746 michael 967 if (conf_parser_ctx.pass == 2)
1747 michael 1228 yy_aconf->flags |= CONF_FLAGS_EXEMPTRESV;
1748 adx 30 } | NEED_PASSWORD
1749     {
1750 michael 967 if (conf_parser_ctx.pass == 2)
1751 michael 1228 yy_aconf->flags |= CONF_FLAGS_NEED_PASSWORD;
1752 adx 30 };
1753    
1754     /* XXX - need check for illegal hostnames here */
1755     auth_spoof: SPOOF '=' QSTRING ';'
1756     {
1757 michael 967 if (conf_parser_ctx.pass == 2)
1758 adx 30 {
1759     MyFree(yy_conf->name);
1760    
1761     if (strlen(yylval.string) < HOSTLEN)
1762     {
1763     DupString(yy_conf->name, yylval.string);
1764     yy_aconf->flags |= CONF_FLAGS_SPOOF_IP;
1765     }
1766     else
1767     {
1768 michael 1247 ilog(LOG_TYPE_IRCD, "Spoofs must be less than %d..ignoring it", HOSTLEN);
1769 adx 30 yy_conf->name = NULL;
1770     }
1771     }
1772     };
1773    
1774     auth_redir_serv: REDIRSERV '=' QSTRING ';'
1775     {
1776 michael 967 if (conf_parser_ctx.pass == 2)
1777 adx 30 {
1778     yy_aconf->flags |= CONF_FLAGS_REDIR;
1779     MyFree(yy_conf->name);
1780     DupString(yy_conf->name, yylval.string);
1781     }
1782     };
1783    
1784     auth_redir_port: REDIRPORT '=' NUMBER ';'
1785     {
1786 michael 967 if (conf_parser_ctx.pass == 2)
1787 adx 30 {
1788     yy_aconf->flags |= CONF_FLAGS_REDIR;
1789     yy_aconf->port = $3;
1790     }
1791     };
1792    
1793    
1794     /***************************************************************************
1795     * section resv
1796     ***************************************************************************/
1797     resv_entry: RESV
1798     {
1799 michael 967 if (conf_parser_ctx.pass == 2)
1800 adx 30 {
1801     MyFree(resv_reason);
1802     resv_reason = NULL;
1803     }
1804     } '{' resv_items '}' ';'
1805     {
1806 michael 967 if (conf_parser_ctx.pass == 2)
1807 adx 30 {
1808     MyFree(resv_reason);
1809     resv_reason = NULL;
1810     }
1811     };
1812    
1813     resv_items: resv_items resv_item | resv_item;
1814     resv_item: resv_creason | resv_channel | resv_nick | error ';' ;
1815    
1816     resv_creason: REASON '=' QSTRING ';'
1817     {
1818 michael 967 if (conf_parser_ctx.pass == 2)
1819 adx 30 {
1820     MyFree(resv_reason);
1821     DupString(resv_reason, yylval.string);
1822     }
1823     };
1824    
1825     resv_channel: CHANNEL '=' QSTRING ';'
1826     {
1827 michael 967 if (conf_parser_ctx.pass == 2)
1828 adx 30 {
1829     if (IsChanPrefix(*yylval.string))
1830     {
1831     char def_reason[] = "No reason";
1832    
1833     create_channel_resv(yylval.string, resv_reason != NULL ? resv_reason : def_reason, 1);
1834     }
1835     }
1836     /* ignore it for now.. but we really should make a warning if
1837     * its an erroneous name --fl_ */
1838     };
1839    
1840     resv_nick: NICK '=' QSTRING ';'
1841     {
1842 michael 967 if (conf_parser_ctx.pass == 2)
1843 adx 30 {
1844     char def_reason[] = "No reason";
1845    
1846     create_nick_resv(yylval.string, resv_reason != NULL ? resv_reason : def_reason, 1);
1847     }
1848     };
1849    
1850     /***************************************************************************
1851 michael 1157 * section service
1852     ***************************************************************************/
1853     service_entry: T_SERVICE '{' service_items '}' ';';
1854    
1855     service_items: service_items service_item | service_item;
1856     service_item: service_name | error;
1857    
1858     service_name: NAME '=' QSTRING ';'
1859     {
1860     if (conf_parser_ctx.pass == 2)
1861     {
1862     if (valid_servname(yylval.string))
1863     {
1864     yy_conf = make_conf_item(SERVICE_TYPE);
1865     DupString(yy_conf->name, yylval.string);
1866     }
1867     }
1868     };
1869    
1870     /***************************************************************************
1871 adx 30 * section shared, for sharing remote klines etc.
1872     ***************************************************************************/
1873     shared_entry: T_SHARED
1874     {
1875 michael 967 if (conf_parser_ctx.pass == 2)
1876 adx 30 {
1877     yy_conf = make_conf_item(ULINE_TYPE);
1878     yy_match_item = map_to_conf(yy_conf);
1879     yy_match_item->action = SHARED_ALL;
1880     }
1881     } '{' shared_items '}' ';'
1882     {
1883 michael 967 if (conf_parser_ctx.pass == 2)
1884 adx 30 {
1885     yy_conf = NULL;
1886     }
1887     };
1888    
1889     shared_items: shared_items shared_item | shared_item;
1890     shared_item: shared_name | shared_user | shared_type | error ';' ;
1891    
1892     shared_name: NAME '=' QSTRING ';'
1893     {
1894 michael 967 if (conf_parser_ctx.pass == 2)
1895 adx 30 {
1896     MyFree(yy_conf->name);
1897     DupString(yy_conf->name, yylval.string);
1898     }
1899     };
1900    
1901     shared_user: USER '=' QSTRING ';'
1902     {
1903 michael 967 if (conf_parser_ctx.pass == 2)
1904 adx 30 {
1905 michael 593 struct split_nuh_item nuh;
1906    
1907     nuh.nuhmask = yylval.string;
1908     nuh.nickptr = NULL;
1909     nuh.userptr = userbuf;
1910     nuh.hostptr = hostbuf;
1911    
1912     nuh.nicksize = 0;
1913     nuh.usersize = sizeof(userbuf);
1914     nuh.hostsize = sizeof(hostbuf);
1915    
1916     split_nuh(&nuh);
1917    
1918     DupString(yy_match_item->user, userbuf);
1919     DupString(yy_match_item->host, hostbuf);
1920 adx 30 }
1921     };
1922    
1923     shared_type: TYPE
1924     {
1925 michael 967 if (conf_parser_ctx.pass == 2)
1926 adx 30 yy_match_item->action = 0;
1927     } '=' shared_types ';' ;
1928    
1929     shared_types: shared_types ',' shared_type_item | shared_type_item;
1930     shared_type_item: KLINE
1931     {
1932 michael 967 if (conf_parser_ctx.pass == 2)
1933 adx 30 yy_match_item->action |= SHARED_KLINE;
1934 michael 1301 } | UNKLINE
1935 adx 30 {
1936 michael 967 if (conf_parser_ctx.pass == 2)
1937 michael 1301 yy_match_item->action |= SHARED_UNKLINE;
1938     } | T_DLINE
1939 adx 30 {
1940 michael 967 if (conf_parser_ctx.pass == 2)
1941 michael 1301 yy_match_item->action |= SHARED_DLINE;
1942     } | T_UNDLINE
1943     {
1944     if (conf_parser_ctx.pass == 2)
1945     yy_match_item->action |= SHARED_UNDLINE;
1946 adx 30 } | XLINE
1947     {
1948 michael 967 if (conf_parser_ctx.pass == 2)
1949 adx 30 yy_match_item->action |= SHARED_XLINE;
1950     } | T_UNXLINE
1951     {
1952 michael 967 if (conf_parser_ctx.pass == 2)
1953 adx 30 yy_match_item->action |= SHARED_UNXLINE;
1954     } | RESV
1955     {
1956 michael 967 if (conf_parser_ctx.pass == 2)
1957 adx 30 yy_match_item->action |= SHARED_RESV;
1958     } | T_UNRESV
1959     {
1960 michael 967 if (conf_parser_ctx.pass == 2)
1961 adx 30 yy_match_item->action |= SHARED_UNRESV;
1962     } | T_LOCOPS
1963     {
1964 michael 967 if (conf_parser_ctx.pass == 2)
1965 adx 30 yy_match_item->action |= SHARED_LOCOPS;
1966     } | T_ALL
1967     {
1968 michael 967 if (conf_parser_ctx.pass == 2)
1969 adx 30 yy_match_item->action = SHARED_ALL;
1970     };
1971    
1972     /***************************************************************************
1973     * section cluster
1974     ***************************************************************************/
1975     cluster_entry: T_CLUSTER
1976     {
1977 michael 967 if (conf_parser_ctx.pass == 2)
1978 adx 30 {
1979     yy_conf = make_conf_item(CLUSTER_TYPE);
1980     yy_conf->flags = SHARED_ALL;
1981     }
1982     } '{' cluster_items '}' ';'
1983     {
1984 michael 967 if (conf_parser_ctx.pass == 2)
1985 adx 30 {
1986     if (yy_conf->name == NULL)
1987     DupString(yy_conf->name, "*");
1988     yy_conf = NULL;
1989     }
1990     };
1991    
1992     cluster_items: cluster_items cluster_item | cluster_item;
1993     cluster_item: cluster_name | cluster_type | error ';' ;
1994    
1995     cluster_name: NAME '=' QSTRING ';'
1996     {
1997 michael 967 if (conf_parser_ctx.pass == 2)
1998 adx 30 DupString(yy_conf->name, yylval.string);
1999     };
2000    
2001     cluster_type: TYPE
2002     {
2003 michael 967 if (conf_parser_ctx.pass == 2)
2004 adx 30 yy_conf->flags = 0;
2005     } '=' cluster_types ';' ;
2006    
2007     cluster_types: cluster_types ',' cluster_type_item | cluster_type_item;
2008     cluster_type_item: KLINE
2009     {
2010 michael 967 if (conf_parser_ctx.pass == 2)
2011 adx 30 yy_conf->flags |= SHARED_KLINE;
2012 michael 1301 } | UNKLINE
2013 adx 30 {
2014 michael 967 if (conf_parser_ctx.pass == 2)
2015 michael 1301 yy_conf->flags |= SHARED_UNKLINE;
2016     } | T_DLINE
2017 adx 30 {
2018 michael 967 if (conf_parser_ctx.pass == 2)
2019 michael 1301 yy_conf->flags |= SHARED_DLINE;
2020     } | T_UNDLINE
2021     {
2022     if (conf_parser_ctx.pass == 2)
2023     yy_conf->flags |= SHARED_UNDLINE;
2024 adx 30 } | XLINE
2025     {
2026 michael 967 if (conf_parser_ctx.pass == 2)
2027 adx 30 yy_conf->flags |= SHARED_XLINE;
2028     } | T_UNXLINE
2029     {
2030 michael 967 if (conf_parser_ctx.pass == 2)
2031 adx 30 yy_conf->flags |= SHARED_UNXLINE;
2032     } | RESV
2033     {
2034 michael 967 if (conf_parser_ctx.pass == 2)
2035 adx 30 yy_conf->flags |= SHARED_RESV;
2036     } | T_UNRESV
2037     {
2038 michael 967 if (conf_parser_ctx.pass == 2)
2039 adx 30 yy_conf->flags |= SHARED_UNRESV;
2040     } | T_LOCOPS
2041     {
2042 michael 967 if (conf_parser_ctx.pass == 2)
2043 adx 30 yy_conf->flags |= SHARED_LOCOPS;
2044     } | T_ALL
2045     {
2046 michael 967 if (conf_parser_ctx.pass == 2)
2047 adx 30 yy_conf->flags = SHARED_ALL;
2048     };
2049    
2050     /***************************************************************************
2051     * section connect
2052     ***************************************************************************/
2053     connect_entry: CONNECT
2054     {
2055 michael 967 if (conf_parser_ctx.pass == 2)
2056 adx 30 {
2057     yy_conf = make_conf_item(SERVER_TYPE);
2058 michael 1265 yy_aconf = map_to_conf(yy_conf);
2059    
2060 adx 30 /* defaults */
2061     yy_aconf->port = PORTNUM;
2062     }
2063     else
2064     {
2065     MyFree(class_name);
2066     class_name = NULL;
2067     }
2068 michael 1285 } '{' connect_items '}' ';'
2069 adx 30 {
2070 michael 967 if (conf_parser_ctx.pass == 2)
2071 adx 30 {
2072     struct CollectItem *yy_hconf=NULL;
2073     struct CollectItem *yy_lconf=NULL;
2074 michael 1302 dlink_node *ptr = NULL, *next_ptr = NULL;
2075    
2076 adx 30 if (yy_aconf->host &&
2077 michael 1302 yy_aconf->passwd && yy_aconf->spasswd)
2078     {
2079     if (conf_add_server(yy_conf, class_name) == -1)
2080     {
2081     delete_conf_item(yy_conf);
2082     yy_conf = NULL;
2083     yy_aconf = NULL;
2084     }
2085     }
2086     else
2087     {
2088     /* Even if yy_conf ->name is NULL
2089     * should still unhook any hub/leaf confs still pending
2090     */
2091     unhook_hub_leaf_confs();
2092 adx 30
2093 michael 1302 if (yy_conf->name != NULL)
2094     {
2095     if (yy_aconf->host == NULL)
2096     yyerror("Ignoring connect block -- missing host");
2097     else if (!yy_aconf->passwd || !yy_aconf->spasswd)
2098     yyerror("Ignoring connect block -- missing password");
2099     }
2100 adx 30
2101    
2102 michael 1302 /* XXX
2103     * This fixes a try_connections() core (caused by invalid class_ptr
2104     * pointers) reported by metalrock. That's an ugly fix, but there
2105     * is currently no better way. The entire config subsystem needs an
2106     * rewrite ASAP. make_conf_item() shouldn't really add things onto
2107     * a doubly linked list immediately without any sanity checks! -Michael
2108     */
2109     delete_conf_item(yy_conf);
2110 adx 30
2111 michael 1302 yy_aconf = NULL;
2112     yy_conf = NULL;
2113     }
2114 adx 30
2115     /*
2116     * yy_conf is still pointing at the server that is having
2117     * a connect block built for it. This means, y_aconf->name
2118     * points to the actual irc name this server will be known as.
2119     * Now this new server has a set or even just one hub_mask (or leaf_mask)
2120     * given in the link list at yy_hconf. Fill in the HUB confs
2121     * from this link list now.
2122     */
2123     DLINK_FOREACH_SAFE(ptr, next_ptr, hub_conf_list.head)
2124     {
2125     struct ConfItem *new_hub_conf;
2126     struct MatchItem *match_item;
2127    
2128     yy_hconf = ptr->data;
2129    
2130     /* yy_conf == NULL is a fatal error for this connect block! */
2131     if ((yy_conf != NULL) && (yy_conf->name != NULL))
2132     {
2133     new_hub_conf = make_conf_item(HUB_TYPE);
2134     match_item = (struct MatchItem *)map_to_conf(new_hub_conf);
2135     DupString(new_hub_conf->name, yy_conf->name);
2136     if (yy_hconf->user != NULL)
2137     DupString(match_item->user, yy_hconf->user);
2138     else
2139     DupString(match_item->user, "*");
2140     if (yy_hconf->host != NULL)
2141     DupString(match_item->host, yy_hconf->host);
2142     else
2143     DupString(match_item->host, "*");
2144     }
2145     dlinkDelete(&yy_hconf->node, &hub_conf_list);
2146     free_collect_item(yy_hconf);
2147     }
2148    
2149     /* Ditto for the LEAF confs */
2150    
2151     DLINK_FOREACH_SAFE(ptr, next_ptr, leaf_conf_list.head)
2152     {
2153     struct ConfItem *new_leaf_conf;
2154     struct MatchItem *match_item;
2155    
2156     yy_lconf = ptr->data;
2157    
2158     if ((yy_conf != NULL) && (yy_conf->name != NULL))
2159     {
2160     new_leaf_conf = make_conf_item(LEAF_TYPE);
2161     match_item = (struct MatchItem *)map_to_conf(new_leaf_conf);
2162     DupString(new_leaf_conf->name, yy_conf->name);
2163     if (yy_lconf->user != NULL)
2164     DupString(match_item->user, yy_lconf->user);
2165     else
2166     DupString(match_item->user, "*");
2167     if (yy_lconf->host != NULL)
2168     DupString(match_item->host, yy_lconf->host);
2169     else
2170     DupString(match_item->host, "*");
2171     }
2172     dlinkDelete(&yy_lconf->node, &leaf_conf_list);
2173     free_collect_item(yy_lconf);
2174     }
2175     MyFree(class_name);
2176     class_name = NULL;
2177     yy_conf = NULL;
2178     yy_aconf = NULL;
2179     }
2180     };
2181    
2182     connect_items: connect_items connect_item | connect_item;
2183     connect_item: connect_name | connect_host | connect_vhost |
2184     connect_send_password | connect_accept_password |
2185 michael 1306 connect_aftype | connect_port | connect_ssl_cipher_list |
2186 michael 1076 connect_flags | connect_hub_mask | connect_leaf_mask |
2187 michael 1302 connect_class | connect_encrypted |
2188 michael 1076 error ';' ;
2189 adx 30
2190     connect_name: NAME '=' QSTRING ';'
2191     {
2192 michael 967 if (conf_parser_ctx.pass == 2)
2193 adx 30 {
2194     if (yy_conf->name != NULL)
2195     yyerror("Multiple connect name entry");
2196    
2197     MyFree(yy_conf->name);
2198     DupString(yy_conf->name, yylval.string);
2199     }
2200     };
2201    
2202     connect_host: HOST '=' QSTRING ';'
2203     {
2204 michael 967 if (conf_parser_ctx.pass == 2)
2205 adx 30 {
2206     MyFree(yy_aconf->host);
2207     DupString(yy_aconf->host, yylval.string);
2208     }
2209     };
2210    
2211     connect_vhost: VHOST '=' QSTRING ';'
2212     {
2213 michael 967 if (conf_parser_ctx.pass == 2)
2214 adx 30 {
2215     struct addrinfo hints, *res;
2216    
2217     memset(&hints, 0, sizeof(hints));
2218    
2219     hints.ai_family = AF_UNSPEC;
2220     hints.ai_socktype = SOCK_STREAM;
2221     hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
2222    
2223 michael 1123 if (getaddrinfo(yylval.string, NULL, &hints, &res))
2224 michael 1247 ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
2225 adx 30 else
2226     {
2227     assert(res != NULL);
2228    
2229     memcpy(&yy_aconf->my_ipnum, res->ai_addr, res->ai_addrlen);
2230     yy_aconf->my_ipnum.ss.ss_family = res->ai_family;
2231     yy_aconf->my_ipnum.ss_len = res->ai_addrlen;
2232 michael 1123 freeaddrinfo(res);
2233 adx 30 }
2234     }
2235     };
2236    
2237     connect_send_password: SEND_PASSWORD '=' QSTRING ';'
2238     {
2239 michael 967 if (conf_parser_ctx.pass == 2)
2240 adx 30 {
2241 adx 38 if ($3[0] == ':')
2242     yyerror("Server passwords cannot begin with a colon");
2243     else if (strchr($3, ' ') != NULL)
2244     yyerror("Server passwords cannot contain spaces");
2245     else {
2246     if (yy_aconf->spasswd != NULL)
2247     memset(yy_aconf->spasswd, 0, strlen(yy_aconf->spasswd));
2248 adx 30
2249 adx 38 MyFree(yy_aconf->spasswd);
2250     DupString(yy_aconf->spasswd, yylval.string);
2251     }
2252 adx 30 }
2253     };
2254    
2255     connect_accept_password: ACCEPT_PASSWORD '=' QSTRING ';'
2256     {
2257 michael 967 if (conf_parser_ctx.pass == 2)
2258 adx 30 {
2259 adx 38 if ($3[0] == ':')
2260     yyerror("Server passwords cannot begin with a colon");
2261     else if (strchr($3, ' ') != NULL)
2262     yyerror("Server passwords cannot contain spaces");
2263     else {
2264     if (yy_aconf->passwd != NULL)
2265     memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
2266 adx 30
2267 adx 38 MyFree(yy_aconf->passwd);
2268     DupString(yy_aconf->passwd, yylval.string);
2269     }
2270 adx 30 }
2271     };
2272    
2273     connect_port: PORT '=' NUMBER ';'
2274     {
2275 michael 967 if (conf_parser_ctx.pass == 2)
2276 adx 30 yy_aconf->port = $3;
2277     };
2278    
2279     connect_aftype: AFTYPE '=' T_IPV4 ';'
2280     {
2281 michael 967 if (conf_parser_ctx.pass == 2)
2282 adx 30 yy_aconf->aftype = AF_INET;
2283     } | AFTYPE '=' T_IPV6 ';'
2284     {
2285     #ifdef IPV6
2286 michael 967 if (conf_parser_ctx.pass == 2)
2287 adx 30 yy_aconf->aftype = AF_INET6;
2288     #endif
2289     };
2290    
2291     connect_flags: IRCD_FLAGS
2292     {
2293     } '=' connect_flags_items ';';
2294    
2295     connect_flags_items: connect_flags_items ',' connect_flags_item | connect_flags_item;
2296 michael 1302 connect_flags_item: AUTOCONN
2297 adx 30 {
2298 michael 967 if (conf_parser_ctx.pass == 2)
2299 michael 1228 SetConfAllowAutoConn(yy_aconf);
2300 adx 30 } | BURST_AWAY
2301     {
2302 michael 967 if (conf_parser_ctx.pass == 2)
2303 michael 1228 SetConfAwayBurst(yy_aconf);
2304 adx 30 } | TOPICBURST
2305     {
2306 michael 967 if (conf_parser_ctx.pass == 2)
2307 michael 1228 SetConfTopicBurst(yy_aconf);
2308 michael 1303 } | T_SSL
2309     {
2310     if (conf_parser_ctx.pass == 2)
2311     SetConfSSL(yy_aconf);
2312 michael 1228 };
2313 adx 30
2314     connect_encrypted: ENCRYPTED '=' TBOOL ';'
2315     {
2316 michael 967 if (conf_parser_ctx.pass == 2)
2317 adx 30 {
2318     if (yylval.number)
2319     yy_aconf->flags |= CONF_FLAGS_ENCRYPTED;
2320     else
2321     yy_aconf->flags &= ~CONF_FLAGS_ENCRYPTED;
2322     }
2323     };
2324    
2325     connect_hub_mask: HUB_MASK '=' QSTRING ';'
2326     {
2327 michael 967 if (conf_parser_ctx.pass == 2)
2328 adx 30 {
2329     struct CollectItem *yy_tmp;
2330    
2331     yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
2332     DupString(yy_tmp->host, yylval.string);
2333     DupString(yy_tmp->user, "*");
2334     dlinkAdd(yy_tmp, &yy_tmp->node, &hub_conf_list);
2335     }
2336     };
2337    
2338     connect_leaf_mask: LEAF_MASK '=' QSTRING ';'
2339     {
2340 michael 967 if (conf_parser_ctx.pass == 2)
2341 adx 30 {
2342     struct CollectItem *yy_tmp;
2343    
2344     yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
2345     DupString(yy_tmp->host, yylval.string);
2346     DupString(yy_tmp->user, "*");
2347     dlinkAdd(yy_tmp, &yy_tmp->node, &leaf_conf_list);
2348     }
2349     };
2350    
2351     connect_class: CLASS '=' QSTRING ';'
2352     {
2353 michael 967 if (conf_parser_ctx.pass == 2)
2354 adx 30 {
2355     MyFree(class_name);
2356     DupString(class_name, yylval.string);
2357     }
2358     };
2359    
2360 michael 1306 connect_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
2361     {
2362     #ifdef HAVE_LIBCRYPTO
2363     if (conf_parser_ctx.pass == 2)
2364     {
2365     MyFree(yy_aconf->cipher_list);
2366     DupString(yy_aconf->cipher_list, yylval.string);
2367     }
2368     #else
2369     if (conf_parser_ctx.pass == 2)
2370     yyerror("Ignoring connect::ciphers -- no OpenSSL support");
2371     #endif
2372     };
2373    
2374    
2375 adx 30 /***************************************************************************
2376     * section kill
2377     ***************************************************************************/
2378     kill_entry: KILL
2379     {
2380 michael 967 if (conf_parser_ctx.pass == 2)
2381 adx 30 {
2382     userbuf[0] = hostbuf[0] = reasonbuf[0] = '\0';
2383     regex_ban = 0;
2384     }
2385     } '{' kill_items '}' ';'
2386     {
2387 michael 967 if (conf_parser_ctx.pass == 2)
2388 adx 30 {
2389     if (userbuf[0] && hostbuf[0])
2390     {
2391     if (regex_ban)
2392     {
2393 michael 1009 #ifdef HAVE_LIBPCRE
2394     void *exp_user = NULL;
2395     void *exp_host = NULL;
2396 adx 30 const char *errptr = NULL;
2397    
2398     if (!(exp_user = ircd_pcre_compile(userbuf, &errptr)) ||
2399     !(exp_host = ircd_pcre_compile(hostbuf, &errptr)))
2400     {
2401 michael 1247 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based K-Line: %s",
2402 michael 595 errptr);
2403 adx 30 break;
2404     }
2405    
2406 michael 1005 yy_aconf = map_to_conf(make_conf_item(RKLINE_TYPE));
2407 adx 30 yy_aconf->regexuser = exp_user;
2408     yy_aconf->regexhost = exp_host;
2409    
2410     DupString(yy_aconf->user, userbuf);
2411     DupString(yy_aconf->host, hostbuf);
2412    
2413     if (reasonbuf[0])
2414     DupString(yy_aconf->reason, reasonbuf);
2415     else
2416     DupString(yy_aconf->reason, "No reason");
2417 michael 1009 #else
2418 michael 1247 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based K-Line: no PCRE support");
2419 michael 1009 break;
2420     #endif
2421 adx 30 }
2422     else
2423     {
2424 michael 1005 yy_aconf = map_to_conf(make_conf_item(KLINE_TYPE));
2425 adx 30
2426     DupString(yy_aconf->user, userbuf);
2427     DupString(yy_aconf->host, hostbuf);
2428    
2429     if (reasonbuf[0])
2430     DupString(yy_aconf->reason, reasonbuf);
2431     else
2432     DupString(yy_aconf->reason, "No reason");
2433     add_conf_by_address(CONF_KILL, yy_aconf);
2434     }
2435     }
2436    
2437     yy_aconf = NULL;
2438     }
2439     };
2440    
2441     kill_type: TYPE
2442     {
2443     } '=' kill_type_items ';';
2444    
2445     kill_type_items: kill_type_items ',' kill_type_item | kill_type_item;
2446     kill_type_item: REGEX_T
2447     {
2448 michael 967 if (conf_parser_ctx.pass == 2)
2449 adx 30 regex_ban = 1;
2450     };
2451    
2452     kill_items: kill_items kill_item | kill_item;
2453     kill_item: kill_user | kill_reason | kill_type | error;
2454    
2455     kill_user: USER '=' QSTRING ';'
2456     {
2457 michael 967 if (conf_parser_ctx.pass == 2)
2458 adx 30 {
2459 michael 593 struct split_nuh_item nuh;
2460 adx 30
2461 michael 593 nuh.nuhmask = yylval.string;
2462     nuh.nickptr = NULL;
2463     nuh.userptr = userbuf;
2464     nuh.hostptr = hostbuf;
2465 adx 30
2466 michael 593 nuh.nicksize = 0;
2467     nuh.usersize = sizeof(userbuf);
2468     nuh.hostsize = sizeof(hostbuf);
2469 adx 30
2470 michael 593 split_nuh(&nuh);
2471 adx 30 }
2472     };
2473    
2474     kill_reason: REASON '=' QSTRING ';'
2475     {
2476 michael 967 if (conf_parser_ctx.pass == 2)
2477 adx 30 strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
2478     };
2479    
2480     /***************************************************************************
2481     * section deny
2482     ***************************************************************************/
2483     deny_entry: DENY
2484     {
2485 michael 967 if (conf_parser_ctx.pass == 2)
2486 michael 1005 hostbuf[0] = reasonbuf[0] = '\0';
2487 adx 30 } '{' deny_items '}' ';'
2488     {
2489 michael 967 if (conf_parser_ctx.pass == 2)
2490 adx 30 {
2491 michael 1005 if (hostbuf[0] && parse_netmask(hostbuf, NULL, NULL) != HM_HOST)
2492     {
2493     yy_aconf = map_to_conf(make_conf_item(DLINE_TYPE));
2494     DupString(yy_aconf->host, hostbuf);
2495    
2496     if (reasonbuf[0])
2497     DupString(yy_aconf->reason, reasonbuf);
2498     else
2499     DupString(yy_aconf->reason, "No reason");
2500 adx 30 add_conf_by_address(CONF_DLINE, yy_aconf);
2501 michael 1005 yy_aconf = NULL;
2502     }
2503 adx 30 }
2504     };
2505    
2506     deny_items: deny_items deny_item | deny_item;
2507     deny_item: deny_ip | deny_reason | error;
2508    
2509     deny_ip: IP '=' QSTRING ';'
2510     {
2511 michael 967 if (conf_parser_ctx.pass == 2)
2512 michael 1005 strlcpy(hostbuf, yylval.string, sizeof(hostbuf));
2513 adx 30 };
2514    
2515     deny_reason: REASON '=' QSTRING ';'
2516     {
2517 michael 967 if (conf_parser_ctx.pass == 2)
2518 michael 1005 strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
2519 adx 30 };
2520    
2521     /***************************************************************************
2522     * section exempt
2523     ***************************************************************************/
2524     exempt_entry: EXEMPT '{' exempt_items '}' ';';
2525    
2526     exempt_items: exempt_items exempt_item | exempt_item;
2527     exempt_item: exempt_ip | error;
2528    
2529     exempt_ip: IP '=' QSTRING ';'
2530     {
2531 michael 967 if (conf_parser_ctx.pass == 2)
2532 adx 30 {
2533     if (yylval.string[0] && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
2534     {
2535 michael 1005 yy_aconf = map_to_conf(make_conf_item(EXEMPTDLINE_TYPE));
2536 adx 30 DupString(yy_aconf->host, yylval.string);
2537    
2538     add_conf_by_address(CONF_EXEMPTDLINE, yy_aconf);
2539     yy_aconf = NULL;
2540     }
2541     }
2542     };
2543    
2544     /***************************************************************************
2545     * section gecos
2546     ***************************************************************************/
2547     gecos_entry: GECOS
2548     {
2549 michael 967 if (conf_parser_ctx.pass == 2)
2550 adx 30 {
2551     regex_ban = 0;
2552     reasonbuf[0] = gecos_name[0] = '\0';
2553     }
2554     } '{' gecos_items '}' ';'
2555     {
2556 michael 967 if (conf_parser_ctx.pass == 2)
2557 adx 30 {
2558     if (gecos_name[0])
2559     {
2560     if (regex_ban)
2561     {
2562 michael 1009 #ifdef HAVE_LIBPCRE
2563     void *exp_p = NULL;
2564 adx 30 const char *errptr = NULL;
2565    
2566     if (!(exp_p = ircd_pcre_compile(gecos_name, &errptr)))
2567     {
2568 michael 1247 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based X-Line: %s",
2569 michael 595 errptr);
2570 adx 30 break;
2571     }
2572    
2573     yy_conf = make_conf_item(RXLINE_TYPE);
2574     yy_conf->regexpname = exp_p;
2575 michael 1009 #else
2576 michael 1247 ilog(LOG_TYPE_IRCD, "Failed to add regular expression based X-Line: no PCRE support");
2577 michael 1009 break;
2578     #endif
2579 adx 30 }
2580     else
2581     yy_conf = make_conf_item(XLINE_TYPE);
2582    
2583     yy_match_item = map_to_conf(yy_conf);
2584     DupString(yy_conf->name, gecos_name);
2585    
2586     if (reasonbuf[0])
2587     DupString(yy_match_item->reason, reasonbuf);
2588     else
2589     DupString(yy_match_item->reason, "No reason");
2590     }
2591     }
2592     };
2593    
2594     gecos_flags: TYPE
2595     {
2596     } '=' gecos_flags_items ';';
2597    
2598     gecos_flags_items: gecos_flags_items ',' gecos_flags_item | gecos_flags_item;
2599     gecos_flags_item: REGEX_T
2600     {
2601 michael 967 if (conf_parser_ctx.pass == 2)
2602 adx 30 regex_ban = 1;
2603     };
2604    
2605     gecos_items: gecos_items gecos_item | gecos_item;
2606     gecos_item: gecos_name | gecos_reason | gecos_flags | error;
2607    
2608     gecos_name: NAME '=' QSTRING ';'
2609     {
2610 michael 967 if (conf_parser_ctx.pass == 2)
2611 adx 30 strlcpy(gecos_name, yylval.string, sizeof(gecos_name));
2612     };
2613    
2614     gecos_reason: REASON '=' QSTRING ';'
2615     {
2616 michael 967 if (conf_parser_ctx.pass == 2)
2617 adx 30 strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
2618     };
2619    
2620     /***************************************************************************
2621     * section general
2622     ***************************************************************************/
2623     general_entry: GENERAL
2624     '{' general_items '}' ';';
2625    
2626     general_items: general_items general_item | general_item;
2627     general_item: general_hide_spoof_ips | general_ignore_bogus_ts |
2628     general_failed_oper_notice | general_anti_nick_flood |
2629     general_max_nick_time | general_max_nick_changes |
2630     general_max_accept | general_anti_spam_exit_message_time |
2631     general_ts_warn_delta | general_ts_max_delta |
2632     general_kill_chase_time_limit | general_kline_with_reason |
2633     general_kline_reason | general_invisible_on_connect |
2634     general_warn_no_nline | general_dots_in_ident |
2635     general_stats_o_oper_only | general_stats_k_oper_only |
2636     general_pace_wait | general_stats_i_oper_only |
2637     general_pace_wait_simple | general_stats_P_oper_only |
2638     general_short_motd | general_no_oper_flood |
2639     general_true_no_oper_flood | general_oper_pass_resv |
2640 michael 1176 general_message_locale |
2641 adx 30 general_oper_only_umodes | general_max_targets |
2642     general_use_egd | general_egdpool_path |
2643     general_oper_umodes | general_caller_id_wait |
2644     general_opers_bypass_callerid | general_default_floodcount |
2645     general_min_nonwildcard | general_min_nonwildcard_simple |
2646 michael 1302 general_disable_remote_commands |
2647     general_client_flood |
2648 adx 30 general_throttle_time | general_havent_read_conf |
2649 michael 1072 general_ping_cookie |
2650 michael 1264 general_disable_auth |
2651 adx 30 general_tkline_expire_notices | general_gline_min_cidr |
2652     general_gline_min_cidr6 | general_use_whois_actually |
2653 michael 584 general_reject_hold_time | general_stats_e_disabled |
2654 michael 1176 general_max_watch | general_services_name |
2655 adx 30 error;
2656    
2657    
2658 michael 876 general_max_watch: MAX_WATCH '=' NUMBER ';'
2659     {
2660     ConfigFileEntry.max_watch = $3;
2661     };
2662 adx 30
2663     general_gline_min_cidr: GLINE_MIN_CIDR '=' NUMBER ';'
2664     {
2665     ConfigFileEntry.gline_min_cidr = $3;
2666     };
2667    
2668     general_gline_min_cidr6: GLINE_MIN_CIDR6 '=' NUMBER ';'
2669     {
2670     ConfigFileEntry.gline_min_cidr6 = $3;
2671     };
2672    
2673     general_use_whois_actually: USE_WHOIS_ACTUALLY '=' TBOOL ';'
2674     {
2675     ConfigFileEntry.use_whois_actually = yylval.number;
2676     };
2677    
2678     general_reject_hold_time: TREJECT_HOLD_TIME '=' timespec ';'
2679     {
2680     GlobalSetOptions.rejecttime = yylval.number;
2681     };
2682    
2683     general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
2684     {
2685     ConfigFileEntry.tkline_expire_notices = yylval.number;
2686     };
2687    
2688 michael 1074 general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' timespec ';'
2689 adx 30 {
2690     ConfigFileEntry.kill_chase_time_limit = $3;
2691     };
2692    
2693     general_hide_spoof_ips: HIDE_SPOOF_IPS '=' TBOOL ';'
2694     {
2695     ConfigFileEntry.hide_spoof_ips = yylval.number;
2696     };
2697    
2698     general_ignore_bogus_ts: IGNORE_BOGUS_TS '=' TBOOL ';'
2699     {
2700     ConfigFileEntry.ignore_bogus_ts = yylval.number;
2701     };
2702    
2703     general_disable_remote_commands: DISABLE_REMOTE_COMMANDS '=' TBOOL ';'
2704     {
2705     ConfigFileEntry.disable_remote = yylval.number;
2706     };
2707    
2708     general_failed_oper_notice: FAILED_OPER_NOTICE '=' TBOOL ';'
2709     {
2710     ConfigFileEntry.failed_oper_notice = yylval.number;
2711     };
2712    
2713     general_anti_nick_flood: ANTI_NICK_FLOOD '=' TBOOL ';'
2714     {
2715     ConfigFileEntry.anti_nick_flood = yylval.number;
2716     };
2717    
2718     general_max_nick_time: MAX_NICK_TIME '=' timespec ';'
2719     {
2720     ConfigFileEntry.max_nick_time = $3;
2721     };
2722    
2723     general_max_nick_changes: MAX_NICK_CHANGES '=' NUMBER ';'
2724     {
2725     ConfigFileEntry.max_nick_changes = $3;
2726     };
2727    
2728     general_max_accept: MAX_ACCEPT '=' NUMBER ';'
2729     {
2730     ConfigFileEntry.max_accept = $3;
2731     };
2732    
2733     general_anti_spam_exit_message_time: ANTI_SPAM_EXIT_MESSAGE_TIME '=' timespec ';'
2734     {
2735     ConfigFileEntry.anti_spam_exit_message_time = $3;
2736     };
2737    
2738     general_ts_warn_delta: TS_WARN_DELTA '=' timespec ';'
2739     {
2740     ConfigFileEntry.ts_warn_delta = $3;
2741     };
2742    
2743     general_ts_max_delta: TS_MAX_DELTA '=' timespec ';'
2744     {
2745 michael 967 if (conf_parser_ctx.pass == 2)
2746 adx 30 ConfigFileEntry.ts_max_delta = $3;
2747     };
2748    
2749     general_havent_read_conf: HAVENT_READ_CONF '=' NUMBER ';'
2750     {
2751 michael 967 if (($3 > 0) && conf_parser_ctx.pass == 1)
2752 adx 30 {
2753 michael 1247 ilog(LOG_TYPE_IRCD, "You haven't read your config file properly.");
2754     ilog(LOG_TYPE_IRCD, "There is a line in the example conf that will kill your server if not removed.");
2755     ilog(LOG_TYPE_IRCD, "Consider actually reading/editing the conf file, and removing this line.");
2756 adx 30 exit(0);
2757     }
2758     };
2759    
2760     general_kline_with_reason: KLINE_WITH_REASON '=' TBOOL ';'
2761     {
2762     ConfigFileEntry.kline_with_reason = yylval.number;
2763     };
2764    
2765     general_kline_reason: KLINE_REASON '=' QSTRING ';'
2766     {
2767 michael 967 if (conf_parser_ctx.pass == 2)
2768 adx 30 {
2769     MyFree(ConfigFileEntry.kline_reason);
2770     DupString(ConfigFileEntry.kline_reason, yylval.string);
2771     }
2772     };
2773    
2774     general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
2775     {
2776     ConfigFileEntry.invisible_on_connect = yylval.number;
2777     };
2778    
2779     general_warn_no_nline: WARN_NO_NLINE '=' TBOOL ';'
2780     {
2781     ConfigFileEntry.warn_no_nline = yylval.number;
2782     };
2783    
2784 michael 584 general_stats_e_disabled: STATS_E_DISABLED '=' TBOOL ';'
2785     {
2786     ConfigFileEntry.stats_e_disabled = yylval.number;
2787     };
2788    
2789 adx 30 general_stats_o_oper_only: STATS_O_OPER_ONLY '=' TBOOL ';'
2790     {
2791     ConfigFileEntry.stats_o_oper_only = yylval.number;
2792     };
2793    
2794     general_stats_P_oper_only: STATS_P_OPER_ONLY '=' TBOOL ';'
2795     {
2796     ConfigFileEntry.stats_P_oper_only = yylval.number;
2797     };
2798    
2799     general_stats_k_oper_only: STATS_K_OPER_ONLY '=' TBOOL ';'
2800     {
2801     ConfigFileEntry.stats_k_oper_only = 2 * yylval.number;
2802     } | STATS_K_OPER_ONLY '=' TMASKED ';'
2803     {
2804     ConfigFileEntry.stats_k_oper_only = 1;
2805     };
2806    
2807     general_stats_i_oper_only: STATS_I_OPER_ONLY '=' TBOOL ';'
2808     {
2809     ConfigFileEntry.stats_i_oper_only = 2 * yylval.number;
2810     } | STATS_I_OPER_ONLY '=' TMASKED ';'
2811     {
2812     ConfigFileEntry.stats_i_oper_only = 1;
2813     };
2814    
2815     general_pace_wait: PACE_WAIT '=' timespec ';'
2816     {
2817     ConfigFileEntry.pace_wait = $3;
2818     };
2819    
2820     general_caller_id_wait: CALLER_ID_WAIT '=' timespec ';'
2821     {
2822     ConfigFileEntry.caller_id_wait = $3;
2823     };
2824    
2825     general_opers_bypass_callerid: OPERS_BYPASS_CALLERID '=' TBOOL ';'
2826     {
2827     ConfigFileEntry.opers_bypass_callerid = yylval.number;
2828     };
2829    
2830     general_pace_wait_simple: PACE_WAIT_SIMPLE '=' timespec ';'
2831     {
2832     ConfigFileEntry.pace_wait_simple = $3;
2833     };
2834    
2835     general_short_motd: SHORT_MOTD '=' TBOOL ';'
2836     {
2837     ConfigFileEntry.short_motd = yylval.number;
2838     };
2839    
2840     general_no_oper_flood: NO_OPER_FLOOD '=' TBOOL ';'
2841     {
2842     ConfigFileEntry.no_oper_flood = yylval.number;
2843     };
2844    
2845     general_true_no_oper_flood: TRUE_NO_OPER_FLOOD '=' TBOOL ';'
2846     {
2847     ConfigFileEntry.true_no_oper_flood = yylval.number;
2848     };
2849    
2850     general_oper_pass_resv: OPER_PASS_RESV '=' TBOOL ';'
2851     {
2852     ConfigFileEntry.oper_pass_resv = yylval.number;
2853     };
2854    
2855     general_message_locale: MESSAGE_LOCALE '=' QSTRING ';'
2856     {
2857 michael 967 if (conf_parser_ctx.pass == 2)
2858 adx 30 {
2859     if (strlen(yylval.string) > LOCALE_LENGTH-2)
2860     yylval.string[LOCALE_LENGTH-1] = '\0';
2861    
2862     set_locale(yylval.string);
2863     }
2864     };
2865    
2866     general_dots_in_ident: DOTS_IN_IDENT '=' NUMBER ';'
2867     {
2868     ConfigFileEntry.dots_in_ident = $3;
2869     };
2870    
2871     general_max_targets: MAX_TARGETS '=' NUMBER ';'
2872     {
2873     ConfigFileEntry.max_targets = $3;
2874     };
2875    
2876     general_use_egd: USE_EGD '=' TBOOL ';'
2877     {
2878     ConfigFileEntry.use_egd = yylval.number;
2879     };
2880    
2881     general_egdpool_path: EGDPOOL_PATH '=' QSTRING ';'
2882     {
2883 michael 967 if (conf_parser_ctx.pass == 2)
2884 adx 30 {
2885     MyFree(ConfigFileEntry.egdpool_path);
2886     DupString(ConfigFileEntry.egdpool_path, yylval.string);
2887     }
2888     };
2889    
2890 michael 1176 general_services_name: T_SERVICES_NAME '=' QSTRING ';'
2891 michael 1157 {
2892 michael 1176 if (conf_parser_ctx.pass == 2 && valid_servname(yylval.string))
2893 michael 1157 {
2894     MyFree(ConfigFileEntry.service_name);
2895     DupString(ConfigFileEntry.service_name, yylval.string);
2896     }
2897     };
2898    
2899 adx 30 general_ping_cookie: PING_COOKIE '=' TBOOL ';'
2900     {
2901     ConfigFileEntry.ping_cookie = yylval.number;
2902     };
2903    
2904     general_disable_auth: DISABLE_AUTH '=' TBOOL ';'
2905     {
2906     ConfigFileEntry.disable_auth = yylval.number;
2907     };
2908    
2909     general_throttle_time: THROTTLE_TIME '=' timespec ';'
2910     {
2911     ConfigFileEntry.throttle_time = yylval.number;
2912     };
2913    
2914     general_oper_umodes: OPER_UMODES
2915     {
2916     ConfigFileEntry.oper_umodes = 0;
2917     } '=' umode_oitems ';' ;
2918    
2919     umode_oitems: umode_oitems ',' umode_oitem | umode_oitem;
2920     umode_oitem: T_BOTS
2921     {
2922     ConfigFileEntry.oper_umodes |= UMODE_BOTS;
2923     } | T_CCONN
2924     {
2925     ConfigFileEntry.oper_umodes |= UMODE_CCONN;
2926 db 849 } | T_CCONN_FULL
2927     {
2928     ConfigFileEntry.oper_umodes |= UMODE_CCONN_FULL;
2929 adx 30 } | T_DEAF
2930     {
2931     ConfigFileEntry.oper_umodes |= UMODE_DEAF;
2932     } | T_DEBUG
2933     {
2934     ConfigFileEntry.oper_umodes |= UMODE_DEBUG;
2935     } | T_FULL
2936     {
2937     ConfigFileEntry.oper_umodes |= UMODE_FULL;
2938 michael 1294 } | HIDDEN
2939     {
2940     ConfigFileEntry.oper_umodes |= UMODE_HIDDEN;
2941 adx 30 } | T_SKILL
2942     {
2943     ConfigFileEntry.oper_umodes |= UMODE_SKILL;
2944     } | T_NCHANGE
2945     {
2946     ConfigFileEntry.oper_umodes |= UMODE_NCHANGE;
2947     } | T_REJ
2948     {
2949     ConfigFileEntry.oper_umodes |= UMODE_REJ;
2950     } | T_UNAUTH
2951     {
2952     ConfigFileEntry.oper_umodes |= UMODE_UNAUTH;
2953     } | T_SPY
2954     {
2955     ConfigFileEntry.oper_umodes |= UMODE_SPY;
2956     } | T_EXTERNAL
2957     {
2958     ConfigFileEntry.oper_umodes |= UMODE_EXTERNAL;
2959     } | T_OPERWALL
2960     {
2961     ConfigFileEntry.oper_umodes |= UMODE_OPERWALL;
2962     } | T_SERVNOTICE
2963     {
2964     ConfigFileEntry.oper_umodes |= UMODE_SERVNOTICE;
2965     } | T_INVISIBLE
2966     {
2967     ConfigFileEntry.oper_umodes |= UMODE_INVISIBLE;
2968     } | T_WALLOP
2969     {
2970     ConfigFileEntry.oper_umodes |= UMODE_WALLOP;
2971     } | T_SOFTCALLERID
2972     {
2973     ConfigFileEntry.oper_umodes |= UMODE_SOFTCALLERID;
2974     } | T_CALLERID
2975     {
2976     ConfigFileEntry.oper_umodes |= UMODE_CALLERID;
2977     } | T_LOCOPS
2978     {
2979     ConfigFileEntry.oper_umodes |= UMODE_LOCOPS;
2980     };
2981    
2982     general_oper_only_umodes: OPER_ONLY_UMODES
2983     {
2984     ConfigFileEntry.oper_only_umodes = 0;
2985     } '=' umode_items ';' ;
2986    
2987     umode_items: umode_items ',' umode_item | umode_item;
2988     umode_item: T_BOTS
2989     {
2990     ConfigFileEntry.oper_only_umodes |= UMODE_BOTS;
2991     } | T_CCONN
2992     {
2993     ConfigFileEntry.oper_only_umodes |= UMODE_CCONN;
2994 db 853 } | T_CCONN_FULL
2995     {
2996     ConfigFileEntry.oper_only_umodes |= UMODE_CCONN_FULL;
2997 adx 30 } | T_DEAF
2998     {
2999     ConfigFileEntry.oper_only_umodes |= UMODE_DEAF;
3000     } | T_DEBUG
3001     {
3002     ConfigFileEntry.oper_only_umodes |= UMODE_DEBUG;
3003     } | T_FULL
3004     {
3005     ConfigFileEntry.oper_only_umodes |= UMODE_FULL;
3006     } | T_SKILL
3007     {
3008     ConfigFileEntry.oper_only_umodes |= UMODE_SKILL;
3009 michael 1294 } | HIDDEN
3010     {
3011     ConfigFileEntry.oper_only_umodes |= UMODE_HIDDEN;
3012 adx 30 } | T_NCHANGE
3013     {
3014     ConfigFileEntry.oper_only_umodes |= UMODE_NCHANGE;
3015     } | T_REJ
3016     {
3017     ConfigFileEntry.oper_only_umodes |= UMODE_REJ;
3018     } | T_UNAUTH
3019     {
3020     ConfigFileEntry.oper_only_umodes |= UMODE_UNAUTH;
3021     } | T_SPY
3022     {
3023     ConfigFileEntry.oper_only_umodes |= UMODE_SPY;
3024     } | T_EXTERNAL
3025     {
3026     ConfigFileEntry.oper_only_umodes |= UMODE_EXTERNAL;
3027     } | T_OPERWALL
3028     {
3029     ConfigFileEntry.oper_only_umodes |= UMODE_OPERWALL;
3030     } | T_SERVNOTICE
3031     {
3032     ConfigFileEntry.oper_only_umodes |= UMODE_SERVNOTICE;
3033     } | T_INVISIBLE
3034     {
3035     ConfigFileEntry.oper_only_umodes |= UMODE_INVISIBLE;
3036     } | T_WALLOP
3037     {
3038     ConfigFileEntry.oper_only_umodes |= UMODE_WALLOP;
3039     } | T_SOFTCALLERID
3040     {
3041     ConfigFileEntry.oper_only_umodes |= UMODE_SOFTCALLERID;
3042     } | T_CALLERID
3043     {
3044     ConfigFileEntry.oper_only_umodes |= UMODE_CALLERID;
3045     } | T_LOCOPS
3046     {
3047     ConfigFileEntry.oper_only_umodes |= UMODE_LOCOPS;
3048     };
3049    
3050     general_min_nonwildcard: MIN_NONWILDCARD '=' NUMBER ';'
3051     {
3052     ConfigFileEntry.min_nonwildcard = $3;
3053     };
3054    
3055     general_min_nonwildcard_simple: MIN_NONWILDCARD_SIMPLE '=' NUMBER ';'
3056     {
3057     ConfigFileEntry.min_nonwildcard_simple = $3;
3058     };
3059    
3060     general_default_floodcount: DEFAULT_FLOODCOUNT '=' NUMBER ';'
3061     {
3062     ConfigFileEntry.default_floodcount = $3;
3063     };
3064    
3065     general_client_flood: T_CLIENT_FLOOD '=' sizespec ';'
3066     {
3067     ConfigFileEntry.client_flood = $3;
3068     };
3069    
3070    
3071     /***************************************************************************
3072     * section glines
3073     ***************************************************************************/
3074     gline_entry: GLINES
3075     {
3076 michael 967 if (conf_parser_ctx.pass == 2)
3077 adx 30 {
3078     yy_conf = make_conf_item(GDENY_TYPE);
3079 michael 102 yy_aconf = map_to_conf(yy_conf);
3080 adx 30 }
3081     } '{' gline_items '}' ';'
3082     {
3083 michael 967 if (conf_parser_ctx.pass == 2)
3084 adx 30 {
3085     /*
3086     * since we re-allocate yy_conf/yy_aconf after the end of action=, at the
3087     * end we will have one extra, so we should free it.
3088     */
3089 michael 102 if (yy_conf->name == NULL || yy_aconf->user == NULL)
3090 adx 30 {
3091 michael 102 delete_conf_item(yy_conf);
3092 adx 30 yy_conf = NULL;
3093     yy_aconf = NULL;
3094     }
3095     }
3096     };
3097    
3098     gline_items: gline_items gline_item | gline_item;
3099     gline_item: gline_enable |
3100     gline_duration |
3101     gline_logging |
3102     gline_user |
3103     gline_server |
3104     gline_action |
3105     error;
3106    
3107     gline_enable: ENABLE '=' TBOOL ';'
3108     {
3109 michael 967 if (conf_parser_ctx.pass == 2)
3110 adx 30 ConfigFileEntry.glines = yylval.number;
3111     };
3112    
3113     gline_duration: DURATION '=' timespec ';'
3114     {
3115 michael 967 if (conf_parser_ctx.pass == 2)
3116 adx 30 ConfigFileEntry.gline_time = $3;
3117     };
3118    
3119 michael 1247 gline_logging: T_LOG
3120 adx 30 {
3121 michael 967 if (conf_parser_ctx.pass == 2)
3122 adx 30 ConfigFileEntry.gline_logging = 0;
3123     } '=' gline_logging_types ';';
3124     gline_logging_types: gline_logging_types ',' gline_logging_type_item | gline_logging_type_item;
3125     gline_logging_type_item: T_REJECT
3126     {
3127 michael 967 if (conf_parser_ctx.pass == 2)
3128 adx 30 ConfigFileEntry.gline_logging |= GDENY_REJECT;
3129     } | T_BLOCK
3130     {
3131 michael 967 if (conf_parser_ctx.pass == 2)
3132 adx 30 ConfigFileEntry.gline_logging |= GDENY_BLOCK;
3133     };
3134    
3135     gline_user: USER '=' QSTRING ';'
3136     {
3137 michael 967 if (conf_parser_ctx.pass == 2)
3138 adx 30 {
3139 michael 593 struct split_nuh_item nuh;
3140 adx 30
3141 michael 593 nuh.nuhmask = yylval.string;
3142     nuh.nickptr = NULL;
3143     nuh.userptr = userbuf;
3144     nuh.hostptr = hostbuf;
3145    
3146     nuh.nicksize = 0;
3147     nuh.usersize = sizeof(userbuf);
3148     nuh.hostsize = sizeof(hostbuf);
3149    
3150     split_nuh(&nuh);
3151    
3152 adx 30 if (yy_aconf->user == NULL)
3153     {
3154 michael 593 DupString(yy_aconf->user, userbuf);
3155     DupString(yy_aconf->host, hostbuf);
3156 adx 30 }
3157     else
3158     {
3159 michael 593 struct CollectItem *yy_tmp = MyMalloc(sizeof(struct CollectItem));
3160    
3161     DupString(yy_tmp->user, userbuf);
3162     DupString(yy_tmp->host, hostbuf);
3163    
3164 adx 30 dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
3165     }
3166     }
3167     };
3168    
3169     gline_server: NAME '=' QSTRING ';'
3170     {
3171 michael 967 if (conf_parser_ctx.pass == 2)
3172 adx 30 {
3173     MyFree(yy_conf->name);
3174     DupString(yy_conf->name, yylval.string);
3175     }
3176     };
3177    
3178     gline_action: ACTION
3179     {
3180 michael 967 if (conf_parser_ctx.pass == 2)
3181 adx 30 yy_aconf->flags = 0;
3182     } '=' gdeny_types ';'
3183     {
3184 michael 967 if (conf_parser_ctx.pass == 2)
3185 adx 30 {
3186 michael 102 struct CollectItem *yy_tmp = NULL;
3187 adx 30 dlink_node *ptr, *next_ptr;
3188    
3189     DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
3190     {
3191     struct AccessItem *new_aconf;
3192     struct ConfItem *new_conf;
3193    
3194     yy_tmp = ptr->data;
3195     new_conf = make_conf_item(GDENY_TYPE);
3196 michael 102 new_aconf = map_to_conf(new_conf);
3197 adx 30
3198     new_aconf->flags = yy_aconf->flags;
3199    
3200     if (yy_conf->name != NULL)
3201     DupString(new_conf->name, yy_conf->name);
3202     else
3203     DupString(new_conf->name, "*");
3204     if (yy_aconf->user != NULL)
3205     DupString(new_aconf->user, yy_tmp->user);
3206     else
3207     DupString(new_aconf->user, "*");
3208     if (yy_aconf->host != NULL)
3209     DupString(new_aconf->host, yy_tmp->host);
3210     else
3211     DupString(new_aconf->host, "*");
3212    
3213     dlinkDelete(&yy_tmp->node, &col_conf_list);
3214     }
3215 michael 102
3216     /*
3217     * In case someone has fed us with more than one action= after user/name
3218     * which would leak memory -Michael
3219     */
3220     if (yy_conf->name == NULL || yy_aconf->user == NULL)
3221     delete_conf_item(yy_conf);
3222    
3223     yy_conf = make_conf_item(GDENY_TYPE);
3224     yy_aconf = map_to_conf(yy_conf);
3225 adx 30 }
3226     };
3227    
3228     gdeny_types: gdeny_types ',' gdeny_type_item | gdeny_type_item;
3229     gdeny_type_item: T_REJECT
3230     {
3231 michael 967 if (conf_parser_ctx.pass == 2)
3232 adx 30 yy_aconf->flags |= GDENY_REJECT;
3233     } | T_BLOCK
3234     {
3235 michael 967 if (conf_parser_ctx.pass == 2)
3236 adx 30 yy_aconf->flags |= GDENY_BLOCK;
3237     };
3238    
3239     /***************************************************************************
3240     * section channel
3241     ***************************************************************************/
3242     channel_entry: CHANNEL
3243     '{' channel_items '}' ';';
3244    
3245     channel_items: channel_items channel_item | channel_item;
3246     channel_item: channel_disable_local_channels | channel_use_except |
3247     channel_use_invex | channel_use_knock |
3248     channel_max_bans | channel_knock_delay |
3249 adx 201 channel_knock_delay_channel | channel_max_chans_per_user |
3250     channel_quiet_on_ban | channel_default_split_user_count |
3251     channel_default_split_server_count |
3252     channel_no_create_on_split | channel_restrict_channels |
3253     channel_no_join_on_split | channel_burst_topicwho |
3254     channel_jflood_count | channel_jflood_time |
3255 michael 632 channel_disable_fake_channels | error;
3256 adx 30
3257 michael 632 channel_disable_fake_channels: DISABLE_FAKE_CHANNELS '=' TBOOL ';'
3258     {
3259     ConfigChannel.disable_fake_channels = yylval.number;
3260     };
3261    
3262 adx 30 channel_restrict_channels: RESTRICT_CHANNELS '=' TBOOL ';'
3263     {
3264     ConfigChannel.restrict_channels = yylval.number;
3265     };
3266    
3267     channel_disable_local_channels: DISABLE_LOCAL_CHANNELS '=' TBOOL ';'
3268     {
3269     ConfigChannel.disable_local_channels = yylval.number;
3270     };
3271    
3272     channel_use_except: USE_EXCEPT '=' TBOOL ';'
3273     {
3274     ConfigChannel.use_except = yylval.number;
3275     };
3276    
3277     channel_use_invex: USE_INVEX '=' TBOOL ';'
3278     {
3279     ConfigChannel.use_invex = yylval.number;
3280     };
3281    
3282     channel_use_knock: USE_KNOCK '=' TBOOL ';'
3283     {
3284     ConfigChannel.use_knock = yylval.number;
3285     };
3286    
3287     channel_knock_delay: KNOCK_DELAY '=' timespec ';'
3288     {
3289     ConfigChannel.knock_delay = $3;
3290     };
3291    
3292     channel_knock_delay_channel: KNOCK_DELAY_CHANNEL '=' timespec ';'
3293     {
3294     ConfigChannel.knock_delay_channel = $3;
3295     };
3296    
3297     channel_max_chans_per_user: MAX_CHANS_PER_USER '=' NUMBER ';'
3298     {
3299     ConfigChannel.max_chans_per_user = $3;
3300     };
3301    
3302     channel_quiet_on_ban: QUIET_ON_BAN '=' TBOOL ';'
3303     {
3304     ConfigChannel.quiet_on_ban = yylval.number;
3305     };
3306    
3307     channel_max_bans: MAX_BANS '=' NUMBER ';'
3308     {
3309     ConfigChannel.max_bans = $3;
3310     };
3311    
3312     channel_default_split_user_count: DEFAULT_SPLIT_USER_COUNT '=' NUMBER ';'
3313     {
3314     ConfigChannel.default_split_user_count = $3;
3315     };
3316    
3317     channel_default_split_server_count: DEFAULT_SPLIT_SERVER_COUNT '=' NUMBER ';'
3318     {
3319     ConfigChannel.default_split_server_count = $3;
3320     };
3321    
3322     channel_no_create_on_split: NO_CREATE_ON_SPLIT '=' TBOOL ';'
3323     {
3324     ConfigChannel.no_create_on_split = yylval.number;
3325     };
3326    
3327     channel_no_join_on_split: NO_JOIN_ON_SPLIT '=' TBOOL ';'
3328     {
3329     ConfigChannel.no_join_on_split = yylval.number;
3330     };
3331    
3332     channel_burst_topicwho: BURST_TOPICWHO '=' TBOOL ';'
3333     {
3334     ConfigChannel.burst_topicwho = yylval.number;
3335     };
3336    
3337     channel_jflood_count: JOIN_FLOOD_COUNT '=' NUMBER ';'
3338     {
3339     GlobalSetOptions.joinfloodcount = yylval.number;
3340     };
3341    
3342     channel_jflood_time: JOIN_FLOOD_TIME '=' timespec ';'
3343     {
3344     GlobalSetOptions.joinfloodtime = yylval.number;
3345     };
3346    
3347     /***************************************************************************
3348     * section serverhide
3349     ***************************************************************************/
3350     serverhide_entry: SERVERHIDE
3351     '{' serverhide_items '}' ';';
3352    
3353     serverhide_items: serverhide_items serverhide_item | serverhide_item;
3354     serverhide_item: serverhide_flatten_links | serverhide_hide_servers |
3355     serverhide_links_delay |
3356     serverhide_disable_hidden |
3357     serverhide_hidden | serverhide_hidden_name |
3358     serverhide_hide_server_ips |
3359     error;
3360    
3361     serverhide_flatten_links: FLATTEN_LINKS '=' TBOOL ';'
3362     {
3363 michael 967 if (conf_parser_ctx.pass == 2)
3364 adx 30 ConfigServerHide.flatten_links = yylval.number;
3365     };
3366    
3367     serverhide_hide_servers: HIDE_SERVERS '=' TBOOL ';'
3368     {
3369 michael 967 if (conf_parser_ctx.pass == 2)
3370 adx 30 ConfigServerHide.hide_servers = yylval.number;
3371     };
3372    
3373     serverhide_hidden_name: HIDDEN_NAME '=' QSTRING ';'
3374     {
3375 michael 967 if (conf_parser_ctx.pass == 2)
3376 adx 30 {
3377     MyFree(ConfigServerHide.hidden_name);
3378     DupString(ConfigServerHide.hidden_name, yylval.string);
3379     }
3380     };
3381    
3382     serverhide_links_delay: LINKS_DELAY '=' timespec ';'
3383     {
3384 michael 967 if (conf_parser_ctx.pass == 2)
3385 adx 30 {
3386     if (($3 > 0) && ConfigServerHide.links_disabled == 1)
3387     {
3388     eventAddIsh("write_links_file", write_links_file, NULL, $3);
3389     ConfigServerHide.links_disabled = 0;
3390     }
3391    
3392     ConfigServerHide.links_delay = $3;
3393     }
3394     };
3395    
3396     serverhide_hidden: HIDDEN '=' TBOOL ';'
3397     {
3398 michael 967 if (conf_parser_ctx.pass == 2)
3399 adx 30 ConfigServerHide.hidden = yylval.number;
3400     };
3401    
3402     serverhide_disable_hidden: DISABLE_HIDDEN '=' TBOOL ';'
3403     {
3404 michael 967 if (conf_parser_ctx.pass == 2)
3405 adx 30 ConfigServerHide.disable_hidden = yylval.number;
3406     };
3407    
3408     serverhide_hide_server_ips: HIDE_SERVER_IPS '=' TBOOL ';'
3409     {
3410 michael 967 if (conf_parser_ctx.pass == 2)
3411 adx 30 ConfigServerHide.hide_server_ips = yylval.number;
3412     };

Properties

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