ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-7.2/src/ircd_parser.y
Revision: 38
Committed: Sun Oct 2 22:27:12 2005 UTC (18 years, 5 months ago) by adx
File size: 87300 byte(s)
Log Message:
- MFC disallow ':' at the beginning and ' ' in server passwords

File Contents

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

Properties

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