ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
Revision: 102
Committed: Mon Oct 10 12:17:19 2005 UTC (18 years, 5 months ago) by michael
Original Path: ircd-hybrid-7.2/src/ircd_parser.y
File size: 88484 byte(s)
Log Message:
- That one should be the propper fix for GDENY items.  Previous fix broke
  the ability of stacking user/name/action combinations.
  That fix still needs to go into -HEAD, and VERY important, into 7.1.3.
  Someone please test this, e.g. write a small dump function that spits out
  GDENY items.

File Contents

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

Properties

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